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

currentProject = None

    36

currentProgram = ""

    37

pouComputed = {}

    38

    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

def GeneratePouProgram(pou_name):

    57

    if not pouComputed.get(pou_name, True):

    58

        pouComputed[pou_name] = True

    59

        global currentProject, currentProgram

    60

        pou = currentProject.getPou(pou_name)

    61

        pou_type = pou.getPouType().getValue()

    62

        if pou_type in pouTypeNames:

    63

            pou_program = PouProgram(pou.getName(), pouTypeNames[pou_type])

    64

        else:

    65

            raise ValueError, "Undefined pou type"

    66

        pou_program.GenerateInterface(pou.getInterface())

    67

        pou_program.GenerateProgram(pou)

    68

        currentProgram += pou_program.GenerateSTProgram()

    69

    70

def GenerateConfiguration(configuration):

    71

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

    72

    for varlist in configuration.getGlobalVars():

    73

        config += "  VAR_GLOBAL"

    74

        if varlist.getRetain():

    75

            config += " RETAIN"

    76

        if varlist.getConstant():

    77

            config += " CONSTANT"

    78

        config += "\n"

    79

        for var in varlist.getVariable():

    80

            var_type = var.getType().getValue()

    81

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

    82

            address = var.getAddress()

    83

            if address:

    84

                config += "AT %s "%address

    85

            config += ": %s"%var_type

    86

            initial = var.getInitialValue()

    87

            if initial:

    88

                value = str(initial.getValue())

    89

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

    90

                if var_type == "STRING":

    91

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

    92

                elif var_type == "WSTRING":

    93

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

    94

                else:

    95

                    config += " := %s"%value

    96

            config += ";\n"

    97

        config += "  END_VAR\n"

    98

    for resource in configuration.getResource():

    99

        config += GenerateResource(resource)

   100

    config += "END_CONFIGURATION\n"

   101

    return config

   102

   103

def GenerateResource(resource):

   104

    resrce = "\n  RESOURCE %s ON BEREMIZ\n"%resource.getName()

   105

    for varlist in resource.getGlobalVars():

   106

        resrce += "    VAR_GLOBAL"

   107

        if varlist.getRetain():

   108

            resrce += " RETAIN"

   109

        if varlist.getConstant():

   110

            resrce += " CONSTANT"

   111

        resrce += "\n"

   112

        for var in varlist.getVariable():

   113

            var_type = var.getType().getValue()

   114

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

   115

            address = var.getAddress()

   116

            if address:

   117

                resrce += "AT %s "%address

   118

            resrce += ": %s"%var.getType().getValue()

   119

            initial = var.getInitialValue()

   120

            if initial:

   121

                value = str(initial.getValue())

   122

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

   123

                if var_type == "STRING":

   124

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

   125

                elif var_type == "WSTRING":

   126

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

   127

                else:

   128

                    resrce += " := %s"%value

   129

            resrce += ";\n"

   130

        resrce += "    END_VAR\n"

   131

    tasks = resource.getTask()

   132

    for task in tasks:

   133

        resrce += "    TASK %s("%task.getName()

   134

        args = []

   135

        single = task.getSingle()

   136

        if single:

   137

            args.append("SINGLE := %s"%single)

   138

        interval = task.getInterval()

   139

        if interval:

   140

            text = "t#"

   141

            if interval.hour != 0:

   142

                text += "%dh"%interval.hour

   143

            if interval.minute != 0:

   144

                text += "%dm"%interval.minute

   145

            if interval.second != 0:

   146

                text += "%ds"%interval.second

   147

            if interval.microsecond != 0:

   148

                text += "%dms"%(interval.microsecond / 1000)

   149

            args.append("INTERVAL := %s"%text)

   150

        args.append("PRIORITY := %s"%str(task.priority.getValue()))

   151

        resrce += ",".join(args) + ");\n"

   152

    for task in tasks:

   153

        for instance in task.getPouInstance():

   154

            resrce += "    PROGRAM %s WITH %s : %s;\n"%(instance.getName(), task.getName(), instance.getType())

   155

    for instance in resource.getPouInstance():

   156

        resrce += "    PROGRAM %s : %s;\n"%(instance.getName(), instance.getType())

   157

    resrce += "  END_RESOURCE\n"

   158

    return resrce

   159

   160

"""

   161

Module implementing methods for generating PLC programs in ST or IL

   162

"""

   163

   164

class PouProgram:

   165

   166

    def __init__(self, name, type):

   167

        self.Name = name

   168

        self.Type = type

   169

        self.ReturnType = None

   170

        self.Interface = []

   171

        self.InitialSteps = []

   172

        self.ComputedBlocks = {}

   173

        self.ComputedConnectors = {}

   174

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

   175

        self.SFCComputedBlocks = ""

   176

        self.ActionNumber = 0

   177

        self.Program = ""

   178

   179

    def GetActionNumber(self):

   180

        self.ActionNumber += 1

   181

        return self.ActionNumber

   182

   183

    def IsAlreadyDefined(self, name):

   184

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

   185

            for var_type, var_name, var_address, var_initial in vars:

   186

                if name == var_name:

   187

                    return True

   188

        return False

   189

   190

    def GenerateInterface(self, interface):

   191

        if self.Type == "FUNCTION":

   192

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

   193

        for varlist in interface.getContent():

   194

            variables = []

   195

            located = False

   196

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

   197

                type = var.getType().getValue()

   198

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

   199

                    type = type.getName()

   200

                    GeneratePouProgram(type)

   201

                    blocktype = GetBlockType(type)

   202

                    if blocktype:

   203

                        variables.extend(blocktype["initialise"](type, var.getName()))

   204

                        located = False

   205

                else:

   206

                    initial = var.getInitialValue()

   207

                    if initial:

   208

                        initial_value = initial.getValue()

   209

                    else:

   210

                        initial_value = None

   211

                    address = var.getAddress()

   212

                    if address:

   213

                        located = True

   214

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

   215

            if len(variables) > 0:

   216

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

   217

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

   218

   219

    def GenerateProgram(self, pou):

   220

        body = pou.getBody()

   221

        body_content = body.getContent()

   222

        body_type = body_content["name"]

   223

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

   224

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

   225

        elif body_type == "FBD":

   226

            for instance in body.getContentInstances():

   227

                if isinstance(instance, (plcopen.outVariable, plcopen.inOutVariable)):

   228

                    var = instance.getExpression()

   229

                    connections = instance.connectionPointIn.getConnections()

   230

                    if connections and len(connections) == 1:

   231

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

   232

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

   233

                elif isinstance(instance, plcopen.block):

   234

                    type = instance.getTypeName()

   235

                    block_infos = GetBlockType(type)

   236

                    block_infos["generate"](self, instance, body, None)

   237

                elif isinstance(instance, plcopen.connector):

   238

                    connector = instance.getName()

   239

                    if self.ComputedConnectors.get(connector, None):

   240

                        continue 

   241

                    connections = instance.connectionPointIn.getConnections()

   242

                    if connections and len(connections) == 1:

   243

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

   244

        elif body_type == "LD":

   245

            for instance in body.getContentInstances():

   246

                if isinstance(instance, plcopen.coil):

   247

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

   248

                    if len(paths) > 0:

   249

                        paths = tuple(paths)

   250

                    else:

   251

                        paths = paths[0] 

   252

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

   253

                    expression = self.ComputeLDExpression(paths, True)

   254

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

   255

        elif body_type == "SFC":

   256

            for instance in body.getContentInstances():

   257

                if isinstance(instance, plcopen.step):

   258

                    self.GenerateSFCStep(instance, pou)

   259

                elif isinstance(instance, plcopen.actionBlock):

   260

                    self.GenerateSFCStepActions(instance, pou)

   261

                elif isinstance(instance, plcopen.transition):

   262

                    self.GenerateSFCTransition(instance, pou)

   263

                elif isinstance(instance, plcopen.jumpStep):

   264

                    self.GenerateSFCJump(instance, pou)

   265

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

   266

                action_name = "COMPUTE_FUNCTION_BLOCKS"

   267

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

   268

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

   269

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

   270

                self.Program = ""

   271

            for initialstep in self.InitialSteps:

   272

                self.ComputeSFCStep(initialstep)

   273

   274

    def ComputeFBDExpression(self, body, link):

   275

        localid = link.getRefLocalId()

   276

        instance = body.getContentInstance(localid)

   277

        if isinstance(instance, (plcopen.inVariable, plcopen.inOutVariable)):

   278

            return instance.getExpression()

   279

        elif isinstance(instance, plcopen.block):

   280

            block_type = instance.getTypeName()

   281

            block_infos = GetBlockType(block_type)

   282

            return block_infos["generate"](self, instance, body, link)

   283

        elif isinstance(instance, plcopen.continuation):

   284

            name = instance.getName()

   285

            computed_value = self.ComputedConnectors.get(name, None)

   286

            if computed_value != None:

   287

                return computed_value

   288

            for tmp_instance in body.getContentInstances():

   289

                if isinstance(tmp_instance, plcopen.connector):

   290

                    if tmp_instance.getName() == name:

   291

                        connections = tmp_instance.connectionPointIn.getConnections()

   292

                        if connections and len(connections) == 1:

   293

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

   294

                            self.ComputedConnectors[name] = expression

   295

                            return expression

   296

            raise ValueError, "No connector found"

   297

   298

    def GenerateLDPaths(self, connections, body):

   299

        paths = []

   300

        for connection in connections:

   301

            localId = connection.getRefLocalId()

   302

            next = body.getContentInstance(localId)

   303

            if isinstance(next, plcopen.leftPowerRail):

   304

                paths.append(None)

   305

            elif isinstance(next, plcopen.block):

   306

                block_type = next.getTypeName()

   307

                block_infos = GetBlockType(block_type)

   308

                paths.append(block_infos["generate"](self, next, body, connection))

   309

            else:

   310

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

   311

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

   312

                if len(result) > 1:

   313

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

   314

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

   315

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

   316

                elif result[0]:

   317

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

   318

                else:

   319

                    paths.append(variable)

   320

        return paths

   321

   322

    def GetNetworkType(self, connections, body):

   323

        network_type = "FBD"

   324

        for connection in connections:

   325

            localId = connection.getRefLocalId()

   326

            next = body.getContentInstance(localId)

   327

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

   328

                return "LD"

   329

            elif isinstance(next, plcopen.block):

   330

                 for variable in next.inputVariables.getVariable():

   331

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

   332

                     if result != "FBD":

   333

                         return result

   334

            elif isinstance(next, plcopen.inVariable):

   335

                return "FBD"

   336

            elif isinstance(next, plcopen.inOutVariable):

   337

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

   338

            else:

   339

                return None

   340

        return "FBD"

   341

   342

    def ExtractDivergenceInput(self, divergence, pou):

   343

        connectionPointIn = divergence.getConnectionPointIn()

   344

        if connectionPointIn:

   345

            connections = connectionPointIn.getConnections()

   346

            if len(connections) == 1:

   347

                instanceLocalId = connections[0].getRefLocalId()

   348

                return pou.body.getContentInstance(instanceLocalId)

   349

        return None

   350

   351

    def ExtractConvergenceInputs(self, convergence, pou):

   352

        instances = []

   353

        for connectionPointIn in convergence.getConnectionPointIn():

   354

            connections = connectionPointIn.getConnections()

   355

            if len(connections) == 1:

   356

                instanceLocalId = connections[0].getRefLocalId()

   357

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

   358

        return instances

   359

   360

    def GenerateSFCStep(self, step, pou):

   361

        step_name = step.getName()

   362

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

   363

            if step.getInitialStep():

   364

                self.InitialSteps.append(step_name)

   365

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

   366

            if step.connectionPointIn:

   367

                instances = []

   368

                connections = step.connectionPointIn.getConnections()

   369

                if len(connections) == 1:

   370

                    instanceLocalId = connections[0].getRefLocalId()

   371

                    instance = pou.body.getContentInstance(instanceLocalId)

   372

                    if isinstance(instance, plcopen.transition):

   373

                        instances.append(instance)

   374

                    elif isinstance(instance, plcopen.selectionConvergence):

   375

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

   376

                    elif isinstance(instance, plcopen.simultaneousDivergence):

   377

                        transition = self.ExtractDivergenceInput(instance, pou)

   378

                        if transition:

   379

                            if isinstance(transition, plcopen.transition):

   380

                                instances.append(transition)

   381

                            elif isinstance(transition, plcopen.selectionConvergence):

   382

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

   383

                for instance in instances:

   384

                    self.GenerateSFCTransition(instance, pou)

   385

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

   386

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

   387

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

   388

   389

    def GenerateSFCJump(self, jump, pou):

   390

        jump_target = jump.getTargetName()

   391

        if jump.connectionPointIn:

   392

            instances = []

   393

            connections = jump.connectionPointIn.getConnections()

   394

            if len(connections) == 1:

   395

                instanceLocalId = connections[0].getRefLocalId()

   396

                instance = pou.body.getContentInstance(instanceLocalId)

   397

                if isinstance(instance, plcopen.transition):

   398

                    instances.append(instance)

   399

                elif isinstance(instance, plcopen.selectionConvergence):

   400

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

   401

                elif isinstance(instance, plcopen.simultaneousDivergence):

   402

                    transition = self.ExtractDivergenceInput(instance, pou)

   403

                    if transition:

   404

                        if isinstance(transition, plcopen.transition):

   405

                            instances.append(transition)

   406

                        elif isinstance(transition, plcopen.selectionConvergence):

   407

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

   408

            for instance in instances:

   409

                self.GenerateSFCTransition(instance, pou)

   410

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

   411

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

   412

   413

    def GenerateSFCStepActions(self, actionBlock, pou):

   414

        connections = actionBlock.connectionPointIn.getConnections()

   415

        if len(connections) == 1:

   416

            stepLocalId = connections[0].getRefLocalId()

   417

            step = pou.body.getContentInstance(stepLocalId)

   418

            self.GenerateSFCStep(step, pou)

   419

            step_name = step.getName()

   420

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

   421

                actions = actionBlock.getActions()

   422

                for action in actions:

   423

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

   424

                    if "duration" in action:

   425

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

   426

                    if "indicator" in action:

   427

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

   428

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

   429

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

   430

                    else:

   431

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

   432

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

   433

                        action_infos["content"] = action_name

   434

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

   435

   436

    def GenerateSFCAction(self, action_name, pou):

   437

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

   438

            actionContent = pou.getAction(action_name)

   439

            if actionContent:

   440

                actionType = actionContent.getBodyType()

   441

                actionBody = actionContent.getBody()

   442

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

   443

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

   444

                elif actionType == "FBD":

   445

                    for instance in actionBody.getContentInstances():

   446

                        if isinstance(instance, plcopen.outVariable):

   447

                            var = instance.getExpression()

   448

                            connections = instance.connectionPointIn.getConnections()

   449

                            if connections and len(connections) == 1:

   450

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

   451

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

   452

                                self.Program = ""

   453

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

   454

                elif actionType == "LD":

   455

                    for instance in actionbody.getContentInstances():

   456

                        if isinstance(instance, plcopen.coil):

   457

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

   458

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

   459

                            expression = self.ComputeLDExpression(paths, True)

   460

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

   461

                            self.Program = ""

   462

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

   463

   464

    def GenerateSFCTransition(self, transition, pou):

   465

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

   466

            steps = []

   467

            connections = transition.connectionPointIn.getConnections()

   468

            if len(connections) == 1:

   469

                instanceLocalId = connections[0].getRefLocalId()

   470

                instance = pou.body.getContentInstance(instanceLocalId)

   471

                if isinstance(instance, plcopen.step):

   472

                    steps.append(instance)

   473

                elif isinstance(instance, plcopen.selectionDivergence):

   474

                    step = self.ExtractDivergenceInput(instance, pou)

   475

                    if step:

   476

                        if isinstance(step, plcopen.step):

   477

                            steps.append(step)

   478

                        elif isinstance(step, plcopen.simultaneousConvergence):

   479

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

   480

                elif isinstance(instance, plcopen.simultaneousConvergence):

   481

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

   482

            transition_infos = {"priority": transition.getPriority(), "from": [], "to" : []}

   483

            transitionValues = transition.getConditionContent()

   484

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

   485

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

   486

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

   487

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

   488

                transitionType = transitionContent.getBodyType()

   489

                transitionBody = transitionContent.getBody()

   490

                if transitionType == "IL":

   491

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

   492

                elif transitionType == "ST":

   493

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

   494

                elif transitionType == "FBD":

   495

                    for instance in transitionBody.getContentInstances():

   496

                        if isinstance(instance, plcopen.outVariable):