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

    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

    39

def ReIndentText(text, nb_spaces):

    40

    compute = ""

    41

    lines = text.splitlines()

    42

    if len(lines) > 0:

    43

        spaces = 0

    44

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

    45

            spaces += 1

    46

        indent = ""

    47

        for i in xrange(spaces, nb_spaces):

    48

            indent += " "

    49

        for line in lines:

    50

            if line != "":

    51

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

    52

            else:

    53

                compute += "\n"

    54

    return compute

    55

    56

"""

    57

Module implementing methods for generating PLC programs in ST or IL

    58

"""

    59

    60

class PouProgram:

    61

    62

    def __init__(self, name, type):

    63

        self.Name = name

    64

        self.Type = type

    65

        self.ReturnType = None

    66

        self.Interface = []

    67

        self.InitialSteps = []

    68

        self.BlockComputed = {}

    69

        self.ComputedBlocks = ""

    70

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

    71

        self.ActionNumber = 0

    72

        self.Program = ""

    73

    74

    def GetActionNumber(self):

    75

        self.ActionNumber += 1

    76

        return self.ActionNumber

    77

    78

    def IsAlreadyDefined(self, name):

    79

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

    80

            for var_type, var_name, var_address, var_initial in vars:

    81

                if name == var_name:

    82

                    return True

    83

        return False

    84

    85

    def GenerateInterface(self, interface):

    86

        if self.Type == "FUNCTION":

    87

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

    88

        for varlist in interface.getContent():

    89

            variables = []

    90

            located = False

    91

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

    92

                type = var.getType().getValue()

    93

                if not isinstance(type, (StringType, UnicodeType)):

    94

                    type = type.getName()

    96

                initial = var.getInitialValue()

    97

                if initial:

    98

                    initial_value = initial.getValue()

    99

                else:

   100

                    initial_value = None

   101

                address = var.getAddress()

   102

                if address:

   103

                    located = True

   104

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

   105

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

   106

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

   107

   108

    def GenerateProgram(self, pou):

   109

        body = pou.getBody()

   110

        body_content = body.getContent()

   111

        body_type = body_content["name"]

   112

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

   113

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

   114

        elif body_type == "FBD":

   115

            for instance in body.getContentInstances():

   116

                if isinstance(instance, plcopen.outVariable):

   117

                    var = instance.getExpression()

   118

                    connections = instance.connectionPointIn.getConnections()

   119

                    if connections and len(connections) == 1:

   120

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

   121

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

   122

        elif body_type == "LD":

   123

            for instance in body.getContentInstances():

   124

                if isinstance(instance, plcopen.coil):

   125

                    paths = self.GenerateLDPaths(instance.connectionPointIn.getConnections(), body)

   126

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

   127

                    expression = self.ComputeLDExpression(paths, True)

   128

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

   129

        elif body_type == "SFC":

   130

            for instance in body.getContentInstances():

   131

                if isinstance(instance, plcopen.step):

   132

                    self.GenerateSFCStep(instance, pou)

   133

                elif isinstance(instance, plcopen.actionBlock):

   134

                    self.GenerateSFCStepActions(instance, pou)

   135

                elif isinstance(instance, plcopen.transition):

   136

                    self.GenerateSFCTransition(instance, pou)

   137

                elif isinstance(instance, plcopen.jumpStep):

   138

                    self.GenerateSFCJump(instance, pou)

   139

            if len(self.InitialSteps) > 0 and self.ComputedBlocks != "":

   140

                action_name = "COMPUTE_FUNCTION_BLOCKS"

   141

                action_infos = {"qualifier" : "S", "content" : action_name}

   142

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

   143

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

   144

                self.Program = ""

   145

            else:

   146

                raise Exception

   147

            for initialstep in self.InitialSteps:

   148

                self.ComputeSFCStep(initialstep)

   149

   150

    def ComputeFBDExpression(self, body, link):

   151

        localid = link.getRefLocalId()

   152

        instance = body.getContentInstance(localid)

   153

        if isinstance(instance, plcopen.inVariable):

   154

            return instance.getExpression()

   155

        elif isinstance(instance, plcopen.block):

   156

            name = instance.getInstanceName()

   157

            type = instance.getTypeName()

   158

            block_infos = GetBlockType(type)

   159

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

   161

                vars = []

   162

                for variable in instance.inputVariables.getVariable():

   163

                    connections = variable.connectionPointIn.getConnections()

   164

                    if connections and len(connections) == 1:

   165

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

   166

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

   167

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

   168

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

   169

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

   170

                if not self.BlockComputed.get(name, False):

   171

                    vars = []

   172

                    for variable in instance.inputVariables.getVariable():

   173

                        connections = variable.connectionPointIn.getConnections()

   174

                        if connections and len(connections) == 1:

   175

                            parameter = variable.getFormalParameter()

   176

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

   177

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

   178

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

   179

                    self.BlockComputed[name] = True

   180

                connectionPoint = link.getPosition()[-1]

   181

                for variable in instance.outputVariables.getVariable():

   182

                    blockPointx, blockPointy = variable.connectionPointOut.getRelPosition()

   183

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

   184

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

   185

                raise ValueError, "No output variable found"

   186

   187

    def GenerateLDPaths(self, connections, body):

   188

        paths = []

   189

        for connection in connections:

   190

            localId = connection.getRefLocalId()

   191

            next = body.getContentInstance(localId)

   192

            if isinstance(next, plcopen.leftPowerRail):

   193

                paths.append(None)

   194

            else:

   195

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

   196

                result = self.GenerateLDPaths(next.connectionPointIn.getConnections(), body)

   197

                if len(result) > 1:

   198

                    paths.append([variable, tuple(result)])

   199

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

   200

                    paths.append([variable] + result[0])

   201

                elif result[0]:

   202

                    paths.append([variable, result[0]])

   203

                else:

   204

                    paths.append(variable)

   205

        return paths

   206

   207

    def GetNetworkType(self, connections, body):

   208

        network_type = "FBD"

   209

        for connection in connections:

   210

            localId = connection.getRefLocalId()

   211

            next = body.getContentInstance(localId)

   212

            if isinstance(next, plcopen.leftPowerRail) or isinstance(next, plcopen.contact):

   213

                return "LD"

   214

            elif isinstance(next, plcopen.block):

   215

                 for variable in next.inputVariables.getVariable():

   216

                     result = self.GetNetworkType(variable.connectionPointIn.getConnections(), body)

   217

                     if result != "FBD":

   218

                         return result

   219

            elif isinstance(next, plcopen.inVariable):

   220

                return "FBD"

   221

            elif isinstance(next, plcopen.inOutVariable):

   222

                return self.GetNetworkType(next.connectionPointIn.getConnections(), body)

   223

            else:

   224

                return None

   225

        return "FBD"

   226

   227

    def ExtractDivergenceInput(self, divergence, pou):

   228

        connectionPointIn = divergence.getConnectionPointIn()

   229

        if connectionPointIn:

   230

            connections = connectionPointIn.getConnections()

   231

            if len(connections) == 1:

   232

                instanceLocalId = connections[0].getRefLocalId()

   233

                return pou.body.getContentInstance(instanceLocalId)

   234

        return None

   235

   236

    def ExtractConvergenceInputs(self, convergence, pou):

   237

        instances = []

   238

        for connectionPointIn in convergence.getConnectionPointIn():

   239

            connections = connectionPointIn.getConnections()

   240

            if len(connections) == 1:

   241

                instanceLocalId = connections[0].getRefLocalId()

   242

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

   243

        return instances

   244

   245

    def GenerateSFCStep(self, step, pou):

   246

        step_name = step.getName()

   247

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

   248

            if step.getInitialStep():

   249

                self.InitialSteps.append(step_name)

   250

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

   251

            if step.connectionPointIn:

   252

                instances = []

   253

                connections = step.connectionPointIn.getConnections()

   254

                if len(connections) == 1:

   255

                    instanceLocalId = connections[0].getRefLocalId()

   256

                    instance = pou.body.getContentInstance(instanceLocalId)

   257

                    if isinstance(instance, plcopen.transition):

   258

                        instances.append(instance)

   259

                    elif isinstance(instance, plcopen.selectionConvergence):

   260

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

   261

                    elif isinstance(instance, plcopen.simultaneousDivergence):

   262

                        transition = self.ExtractDivergenceInput(instance, pou)

   263

                        if transition:

   264

                            if isinstance(transition, plcopen.transition):

   265

                                instances.append(transition)

   266

                            elif isinstance(transition, plcopen.selectionConvergence):

   267

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

   268

                for instance in instances:

   269

                    self.GenerateSFCTransition(instance, pou)

   270

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

   271

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

   272

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

   273

   274

    def GenerateSFCJump(self, jump, pou):

   275

        jump_target = jump.getTargetName()

   276

        if jump.connectionPointIn:

   277

            instances = []

   278

            connections = jump.connectionPointIn.getConnections()

   279

            if len(connections) == 1:

   280

                instanceLocalId = connections[0].getRefLocalId()

   281

                instance = pou.body.getContentInstance(instanceLocalId)

   282

                if isinstance(instance, plcopen.transition):

   283

                    instances.append(instance)

   284

                elif isinstance(instance, plcopen.selectionConvergence):

   285

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

   286

                elif isinstance(instance, plcopen.simultaneousDivergence):

   287

                    transition = self.ExtractDivergenceInput(instance, pou)

   288

                    if transition:

   289

                        if isinstance(transition, plcopen.transition):

   290

                            instances.append(transition)

   291

                        elif isinstance(transition, plcopen.selectionConvergence):

   292

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

   293

            for instance in instances:

   294

                self.GenerateSFCTransition(instance, pou)

   295

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

   296

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

   297

   298

    def GenerateSFCStepActions(self, actionBlock, pou):

   299

        connections = actionBlock.connectionPointIn.getConnections()

   300

        if len(connections) == 1:

   301

            stepLocalId = connections[0].getRefLocalId()

   302

            step = pou.body.getContentInstance(stepLocalId)

   303

            self.GenerateSFCStep(step, pou)

   304

            step_name = step.getName()

   305

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

   306

                actions = actionBlock.getActions()

   307

                for action in actions:

   308

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

   309

                    if "duration" in action:

   310

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

   311

                    if "indicator" in action:

   312

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

   313

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

   314

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

   315

                    else:

   316

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

   317

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

   318

                        action_infos["content"] = action_name

   319

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

   320

   321

    def GenerateSFCAction(self, action_name, pou):

   322

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

   323

            actionContent = pou.getAction(action_name)

   324

            if actionContent:

   325

                actionType = actionContent.getBodyType()

   326

                actionBody = actionContent.getBody()

   327

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

   328

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

   329

                elif actionType == "FBD":

   330

                    for instance in actionBody.getContentInstances():

   331

                        if isinstance(instance, plcopen.outVariable):

   332

                            var = instance.getExpression()

   333

                            connections = instance.connectionPointIn.getConnections()

   334

                            if connections and len(connections) == 1:

   335

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

   336

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

   337

                                self.Program = ""

   338

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

   339

                elif actionType == "LD":

   340

                    for instance in actionbody.getContentInstances():

   341

                        if isinstance(instance, plcopen.coil):

   342

                            paths = self.GenerateLDPaths(instance.connectionPointIn.getConnections(), actionBody)

   343

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

   344

                            expression = self.ComputeLDExpression(paths, True)

   345

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

   346

                            self.Program = ""

   347

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

   348

   349

    def GenerateSFCTransition(self, transition, pou):

   350

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

   351

            steps = []

   352

            connections = transition.connectionPointIn.getConnections()

   353

            if len(connections) == 1:

   354

                instanceLocalId = connections[0].getRefLocalId()

   355

                instance = pou.body.getContentInstance(instanceLocalId)

   356

                if isinstance(instance, plcopen.step):

   357

                    steps.append(instance)

   358

                elif isinstance(instance, plcopen.selectionDivergence):

   359

                    step = self.ExtractDivergenceInput(instance, pou)

   360

                    if step:

   361

                        if isinstance(step, plcopen.step):

   362

                            steps.append(step)

   363

                        elif isinstance(step, plcopen.simultaneousConvergence):

   364

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

   365

                elif isinstance(instance, plcopen.simultaneousConvergence):

   366

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

   367

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

   368

            transitionValues = transition.getConditionContent()

   369

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

   370

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

   371

            elif transitionValues["type"] == "reference":

   372

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

   373

                transitionType = transitionContent.getBodyType()

   374

                transitionBody = transitionContent.getBody()

   375

                if transitionType == "IL":

   376

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

   377

                elif transitionType == "ST":

   378

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

   379

                elif transitionType == "FBD":

   380

                    for instance in transitionBody.getContentInstances():

   381

                        if isinstance(instance, plcopen.outVariable):

   382

                            connections = instance.connectionPointIn.getConnections()

   383

                            if connections and len(connections) == 1:

   384

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

   385

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

   386

                                self.ComputedBlocks += self.Program

   387

                                self.Program = ""

   388

                elif transitionType == "LD":

   389

                    for instance in transitionBody.getContentInstances():

   390

                        if isinstance(instance, plcopen.coil):

   391

                            paths = self.GenerateLDPaths(instance.connectionPointIn.getConnections(), transitionBody)

   392

                            expression = self.ComputeLDExpression(paths, True)

   393

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

   394

                            self.ComputedBlocks += self.Program

   395

                            self.Program = ""

   396

            elif transitionValues["type"] == "connection":

   397

                body = pou.getBody()

   398

                connections = transition.getConnections()

   399

                network_type = self.GetNetworkType(connections, body)

   400

                if network_type == None:

   401

                    raise Exception

   402

                if len(connections) > 1 or network_type == "LD":

   403

                    paths = self.GenerateLDPaths(connections, body)

   404

                    expression = self.ComputeLDExpression(paths, True)

   405

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

   406

                    self.ComputedBlocks += self.Program

   407

                    self.Program = ""

   408

                else:

   409

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

   410

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

   411

                    self.ComputedBlocks += self.Program

   412

                    self.Program = ""

   413

            for step in steps:

   414

                self.GenerateSFCStep(step, pou)

   415

                step_name = step.getName()

   416

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

   417

                    transition_infos["from"].append(step_name)

   418

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

   419

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

   420

   421

    def ComputeSFCStep(self, step_name):

   422

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

   423

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

   424

            if step_infos["initial"]:

   425

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

   426

            else:

   427

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

   428

            actions = []

   429

            for action_infos in step_infos["actions"]:

   430

                actions.append(action_infos["content"])

   431

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

   432

                if "duration" in action_infos:

   433

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

   434

                if "indicator" in action_infos:

   435

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

   436

                self.Program += ");\n"

   437

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

   438

            for action in actions:

   439

                self.ComputeSFCAction(action)

   440

            for transition in step_infos["transitions"]:

   441

                self.ComputeSFCTransition(transition)

   442

   443

    def ComputeSFCAction(self, action_name):

   444

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

   445

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

   446

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

   447

   448

    def ComputeSFCTransition(self, transition):

   449

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

   450

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

   451

            self.Program += "  TRANSITION FROM "

   452

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

   453

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

   454

            else:

   455

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

   456

            self.Program += " TO "

   457

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

   458

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

   459

            else:

   460

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

   461

            self.Program += transition_infos["content"]

   462

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

   463

            for step_name in transition_infos["to"]:

   464

                self.ComputeSFCStep(step_name)

   465

   466

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

   467

        if type(paths) == TupleType:

   468

            if None in paths:

   469

                return "TRUE"

   470

            else:

   471

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

   472

                if first:

   473

                    return " OR ".join(var)

   474

                else:

   475

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

   476

        elif type(paths) == ListType:

   477

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

   478

            return " AND ".join(var)

   479

        else:

   480

            return paths

   481

   482

    def ExtractModifier(self, variable, text):

   483

        if variable.getNegated():

   484

            return "NOT(%s)"%text

   485

        else:

   486

            edge = variable.getEdge()

   487

            if edge:

   488

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

   489

                    return self.AddTrigger("R_TRIG", text)

   490

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

   491

                    return self.AddTrigger("F_TRIG", text)

   492

        return text

   493

   494

    def AddTrigger(self, edge, text):

   495

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

   496

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

   497

        i = 1

   498

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

   499

        while self.IsAlreadyDefined(name):