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

    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.BlockComputed = {}

    66

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

    67

        self.ActionNumber = 0

    68

        self.Program = ""

    69

    70

    def GetActionNumber(self):

    71

        self.ActionNumber += 1

    72

        return self.ActionNumber

    73

    74

    def IsAlreadyDefined(self, name):

    75

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

    76

            for var_type, var_name, var_address, var_initial in vars:

    77

                if name == var_name:

    78

                    return True

    79

        return False

    80

    81

    def GenerateInterface(self, interface):

    82

        if self.Type == "FUNCTION":

    83

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

    84

        for varlist in interface.getContent():

    85

            variables = []

    86

            located = False

    87

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

    88

                type = var.getType().getValue()

    89

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

    90

                    type = type.getName()

    91

                initial = var.getInitialValue()

    92

                if initial:

    93

                    initial_value = initial.getValue()

    94

                else:

    95

                    initial_value = None

    96

                address = var.getAddress()

    97

                if address:

    98

                    located = True

    99

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

   100

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

   101

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

   102

   103

    def GenerateProgram(self, pou):

   104

        body = pou.getBody()

   105

        body_content = body.getContent()

   106

        body_type = body_content["name"]

   107

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

   108

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

   109

        elif body_type == "FBD":

   110

            for instance in body.getContentInstances():

   111

                if isinstance(instance, plcopen.outVariable):

   112

                    var = instance.getExpression()

   113

                    connections = instance.connectionPointIn.getConnections()

   114

                    if connections and len(connections) == 1:

   115

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

   116

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

   117

        elif body_type == "LD":

   118

            for instance in body.getContentInstances():

   119

                if isinstance(instance, plcopen.coil):

   120

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

   121

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

   122

                    expression = self.ComputeLDExpression(paths, True)

   123

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

   124

        elif body_type == "SFC":

   125

            for instance in body.getContentInstances():

   126

                if isinstance(instance, plcopen.step):

   127

                    self.GenerateSFCStep(instance, pou)

   128

                elif isinstance(instance, plcopen.actionBlock):

   129

                    self.GenerateSFCStepActions(instance, pou)

   130

                elif isinstance(instance, plcopen.transition):

   131

                    self.GenerateSFCTransition(instance, pou)

   132

                elif isinstance(instance, plcopen.jumpStep):

   133

                    self.GenerateSFCJump(instance, pou)

   135

                action_name = "COMPUTE_FUNCTION_BLOCKS"

   136

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

   137

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

   139

                self.Program = ""

   140

            else:

   141

                raise Exception

   142

            for initialstep in self.InitialSteps:

   143

                self.ComputeSFCStep(initialstep)

   144

   145

    def ComputeFBDExpression(self, body, link):

   146

        localid = link.getRefLocalId()

   147

        instance = body.getContentInstance(localid)

   148

        if isinstance(instance, plcopen.inVariable):

   149

            return instance.getExpression()

   150

        elif isinstance(instance, plcopen.block):

   151

            name = instance.getInstanceName()

   152

            type = instance.getTypeName()

   153

            block_infos = GetBlockType(type)

   154

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

   155

                vars = []

   156

                for variable in instance.inputVariables.getVariable():

   157

                    connections = variable.connectionPointIn.getConnections()

   158

                    if connections and len(connections) == 1:

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

                    vars = []

   166

                    for variable in instance.inputVariables.getVariable():

   167

                        connections = variable.connectionPointIn.getConnections()

   168

                        if connections and len(connections) == 1:

   169

                            parameter = variable.getFormalParameter()

   170

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

   171

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

   172

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

   173

                    self.BlockComputed[name] = True

   174

                connectionPoint = link.getPosition()[-1]

   175

                for variable in instance.outputVariables.getVariable():

   176

                    blockPointx, blockPointy = variable.connectionPointOut.getRelPosition()

   177

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

   178

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

   179

                raise ValueError, "No output variable found"

   180

   181

    def GenerateLDPaths(self, connections, body):

   182

        paths = []

   183

        for connection in connections:

   184

            localId = connection.getRefLocalId()

   185

            next = body.getContentInstance(localId)

   186

            if isinstance(next, plcopen.leftPowerRail):

   187

                paths.append(None)

   188

            else:

   189

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

   190

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

   191

                if len(result) > 1:

   192

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

   193

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

   194

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

   195

                elif result[0]:

   196

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

   197

                else:

   198

                    paths.append(variable)

   199

        return paths

   200

   201

    def GetNetworkType(self, connections, body):

   202

        network_type = "FBD"

   203

        for connection in connections:

   204

            localId = connection.getRefLocalId()

   205

            next = body.getContentInstance(localId)

   206

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

   207

                return "LD"

   208

            elif isinstance(next, plcopen.block):

   210

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

   211

                     if result != "FBD":

   212

                         return result

   213

            elif isinstance(next, plcopen.inVariable):

   214

                return "FBD"

   215

            elif isinstance(next, plcopen.inOutVariable):

   216

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

   217

            else:

   218

                return None

   219

        return "FBD"

   220

   221

    def ExtractDivergenceInput(self, divergence, pou):

   222

        connectionPointIn = divergence.getConnectionPointIn()

   223

        if connectionPointIn:

   224

            connections = connectionPointIn.getConnections()

   225

            if len(connections) == 1:

   226

                instanceLocalId = connections[0].getRefLocalId()

   227

                return pou.body.getContentInstance(instanceLocalId)

   228

        return None

   229

   230

    def ExtractConvergenceInputs(self, convergence, pou):

   231

        instances = []

   232

        for connectionPointIn in convergence.getConnectionPointIn():

   233

            connections = connectionPointIn.getConnections()

   234

            if len(connections) == 1:

   235

                instanceLocalId = connections[0].getRefLocalId()

   236

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

   237

        return instances

   238

   239

    def GenerateSFCStep(self, step, pou):

   240

        step_name = step.getName()

   241

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

   242

            if step.getInitialStep():

   243

                self.InitialSteps.append(step_name)

   244

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

   245

            if step.connectionPointIn:

   246

                instances = []

   247

                connections = step.connectionPointIn.getConnections()

   248

                if len(connections) == 1:

   249

                    instanceLocalId = connections[0].getRefLocalId()

   250

                    instance = pou.body.getContentInstance(instanceLocalId)

   251

                    if isinstance(instance, plcopen.transition):

   252

                        instances.append(instance)

   253

                    elif isinstance(instance, plcopen.selectionConvergence):

   254

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

   255

                    elif isinstance(instance, plcopen.simultaneousDivergence):

   256

                        transition = self.ExtractDivergenceInput(instance, pou)

   257

                        if transition:

   258

                            if isinstance(transition, plcopen.transition):

   259

                                instances.append(transition)

   260

                            elif isinstance(transition, plcopen.selectionConvergence):

   261

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

   262

                for instance in instances:

   263

                    self.GenerateSFCTransition(instance, pou)

   264

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

   265

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

   266

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

   267

   268

    def GenerateSFCJump(self, jump, pou):

   269

        jump_target = jump.getTargetName()

   270

        if jump.connectionPointIn:

   271

            instances = []

   272

            connections = jump.connectionPointIn.getConnections()

   273

            if len(connections) == 1:

   274

                instanceLocalId = connections[0].getRefLocalId()

   275

                instance = pou.body.getContentInstance(instanceLocalId)

   276

                if isinstance(instance, plcopen.transition):

   277

                    instances.append(instance)

   278

                elif isinstance(instance, plcopen.selectionConvergence):

   279

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

   280

                elif isinstance(instance, plcopen.simultaneousDivergence):

   281

                    transition = self.ExtractDivergenceInput(instance, pou)

   282

                    if transition:

   283

                        if isinstance(transition, plcopen.transition):

   284

                            instances.append(transition)

   285

                        elif isinstance(transition, plcopen.selectionConvergence):

   286

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

   287

            for instance in instances:

   288

                self.GenerateSFCTransition(instance, pou)

   289

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

   290

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

   291

   292

    def GenerateSFCStepActions(self, actionBlock, pou):

   293

        connections = actionBlock.connectionPointIn.getConnections()

   294

        if len(connections) == 1:

   295

            stepLocalId = connections[0].getRefLocalId()

   296

            step = pou.body.getContentInstance(stepLocalId)

   297

            self.GenerateSFCStep(step, pou)

   298

            step_name = step.getName()

   299

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

   300

                actions = actionBlock.getActions()

   301

                for action in actions:

   302

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

   303

                    if "duration" in action:

   304

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

   305

                    if "indicator" in action:

   306

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

   307

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

   308

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

   309

                    else:

   310

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

   311

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

   312

                        action_infos["content"] = action_name

   313

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

   314

   315

    def GenerateSFCAction(self, action_name, pou):

   316

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

   317

            actionContent = pou.getAction(action_name)

   318

            if actionContent:

   319

                actionType = actionContent.getBodyType()

   320

                actionBody = actionContent.getBody()

   321

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

   322

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

   323

                elif actionType == "FBD":

   324

                    for instance in actionBody.getContentInstances():

   325

                        if isinstance(instance, plcopen.outVariable):

   326

                            var = instance.getExpression()

   327

                            connections = instance.connectionPointIn.getConnections()

   328

                            if connections and len(connections) == 1:

   329

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

   331

                                self.Program = ""

   333

                elif actionType == "LD":

   334

                    for instance in actionbody.getContentInstances():

   335

                        if isinstance(instance, plcopen.coil):

   336

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

   337

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

   338

                            expression = self.ComputeLDExpression(paths, True)

   340

                            self.Program = ""

   342

   343

    def GenerateSFCTransition(self, transition, pou):

   344

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

   345

            steps = []

   346

            connections = transition.connectionPointIn.getConnections()

   347

            if len(connections) == 1:

   348

                instanceLocalId = connections[0].getRefLocalId()

   349

                instance = pou.body.getContentInstance(instanceLocalId)

   350

                if isinstance(instance, plcopen.step):

   351

                    steps.append(instance)

   352

                elif isinstance(instance, plcopen.selectionDivergence):

   353

                    step = self.ExtractDivergenceInput(instance, pou)

   354

                    if step:

   355

                        if isinstance(step, plcopen.step):

   356

                            steps.append(step)

   357

                        elif isinstance(step, plcopen.simultaneousConvergence):

   358

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

   359

                elif isinstance(instance, plcopen.simultaneousConvergence):

   360

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

   361

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

   362

            transitionValues = transition.getConditionContent()

   363

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

   364

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

   365

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

   366

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

   367

                transitionType = transitionContent.getBodyType()

   368

                transitionBody = transitionContent.getBody()

   369

                if transitionType == "IL":

   370

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

   371

                elif transitionType == "ST":

   372

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

   373

                elif transitionType == "FBD":

   374

                    for instance in transitionBody.getContentInstances():

   375

                        if isinstance(instance, plcopen.outVariable):

   376

                            connections = instance.connectionPointIn.getConnections()

   377

                            if connections and len(connections) == 1:

   378

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

   379

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

   382

                elif transitionType == "LD":

   383

                    for instance in transitionBody.getContentInstances():

   384

                        if isinstance(instance, plcopen.coil):

   385

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

   386

                            expression = self.ComputeLDExpression(paths, True)

   387

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

   390

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

   391

                body = pou.getBody()

   392

                connections = transition.getConnections()

   393

                network_type = self.GetNetworkType(connections, body)

   394

                if network_type == None:

   395

                    raise Exception

   396

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

   397

                    paths = self.GenerateLDPaths(connections, body)

   398

                    expression = self.ComputeLDExpression(paths, True)

   399

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

   402

                else:

   403

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

   404

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

   407

            for step in steps:

   408

                self.GenerateSFCStep(step, pou)

   409

                step_name = step.getName()

   410

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

   411

                    transition_infos["from"].append(step_name)

   412

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

   413

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

   414

   415

    def ComputeSFCStep(self, step_name):

   416

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

   417

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

   418

            if step_infos["initial"]:

   419

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

   420

            else:

   421

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

   422

            actions = []

   423

            for action_infos in step_infos["actions"]:

   424

                actions.append(action_infos["content"])

   425

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

   426

                if "duration" in action_infos:

   427

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

   428

                if "indicator" in action_infos:

   429

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

   430

                self.Program += ");\n"

   431

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

   432

            for action in actions:

   433

                self.ComputeSFCAction(action)

   434

            for transition in step_infos["transitions"]:

   435

                self.ComputeSFCTransition(transition)

   436

   437

    def ComputeSFCAction(self, action_name):

   438

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

   439

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

   440

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

   441

   442

    def ComputeSFCTransition(self, transition):

   443

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

   444

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

   445

            self.Program += "  TRANSITION FROM "

   446

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

   447

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

   448

            else:

   449

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

   450

            self.Program += " TO "

   451

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

   452

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

   453

            else:

   454

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

   455

            self.Program += transition_infos["content"]

   456

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

   457

            for step_name in transition_infos["to"]:

   458

                self.ComputeSFCStep(step_name)

   459

   460

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

   461

        if type(paths) == TupleType:

   462

            if None in paths:

   463

                return "TRUE"

   464

            else:

   465

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

   466

                if first:

   467

                    return " OR ".join(var)

   468

                else:

   469

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

   470

        elif type(paths) == ListType:

   471

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

   472

            return " AND ".join(var)

   473

        else:

   474

            return paths

   475

   476

    def ExtractModifier(self, variable, text):

   477

        if variable.getNegated():

   478

            return "NOT(%s)"%text

   479

        else:

   480

            edge = variable.getEdge()

   481

            if edge:

   482

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

   483

                    return self.AddTrigger("R_TRIG", text)

   484

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

   485

                    return self.AddTrigger("F_TRIG", text)

   486

        return text

   487

   488

    def AddTrigger(self, edge, text):

   489

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

   490

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

   491

        i = 1

   492

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

   493

        while self.IsAlreadyDefined(name):

   494

            i += 1

   495

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

   496

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

   497

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

   498

        return "%s.Q"%name

   499

   500

    def GenerateSTProgram(self):