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

datatypeComputed = {}

    38

pouComputed = {}

    39

    40

def ReIndentText(text, nb_spaces):

    41

    compute = ""

    42

    lines = text.splitlines()

    43

    if len(lines) > 0:

    44

        spaces = 0

    45

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

    46

            spaces += 1

    47

        indent = ""

    48

        for i in xrange(spaces, nb_spaces):

    49

            indent += " "

    50

        for line in lines:

    51

            if line != "":

    52

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

    53

            else:

    54

                compute += "\n"

    55

    return compute

    56

    57

def GenerateDataType(datatype_name):

    58

    if not datatypeComputed.get(datatype_name, True):

    59

        datatypeComputed[datatype_name] = True

    60

        global currentProject, currentProgram

    61

        datatype = currentProject.getDataType(datatype_name)

    62

        datatype_def = "  %s :"%datatype.getName()

    63

        basetype_content = datatype.baseType.getContent()

    66

        elif basetype_content["name"] == "derived":

    67

            basetype_name = basetype_content["value"].getName()

    68

            GenerateDataType(basetype_name)

    69

            datatype_def += " %s"%basetype_name

    70

        elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:

    71

            base_type = basetype_content["value"].baseType.getContent()

    75

                basetype_name = base_type["name"]

    76

                GenerateDataType(basetype_name)

    77

            min_value = basetype_content["value"].range.getLower()

    78

            max_value = basetype_content["value"].range.getUpper()

    79

            datatype_def += " %s (%d..%d)"%(basetype_name, min_value, max_value)

    80

        elif basetype_content["name"] == "enum":

    81

            values = []

    82

            for value in basetype_content["value"].values.getValue():

    83

                values.append(value.getName())

    84

            datatype_def += " (%s)"%", ".join(values)

    85

        elif basetype_content["name"] == "array":

    86

            base_type = basetype_content["value"].baseType.getContent()

    92

                basetype_name = base_type["name"]

    93

                GenerateDataType(basetype_name)

    94

            dimensions = []

    95

            for dimension in basetype_content["value"].getDimension():

    96

                dimensions.append("0..%d"%(dimension.getUpper() - 1))

    97

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

   100

        if datatype.initialValue is not None:

   101

            datatype_def += " := %s"%str(datatype.initialValue.getValue())

   102

        currentProgram += "%s;\n"%datatype_def

   103

   104

def GeneratePouProgram(pou_name):

   105

    if not pouComputed.get(pou_name, True):

   106

        pouComputed[pou_name] = True

   107

        global currentProject, currentProgram

   108

        pou = currentProject.getPou(pou_name)

   109

        pou_type = pou.getPouType().getValue()

   110

        if pou_type in pouTypeNames:

   111

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

   112

        else:

   113

            raise ValueError, "Undefined pou type"

   114

        pou_program.GenerateInterface(pou.getInterface())

   115

        pou_program.GenerateConnectionTypes(pou)

   116

        pou_program.GenerateProgram(pou)

   117

        currentProgram += pou_program.GenerateSTProgram()

   118

   119

def GenerateConfiguration(configuration):

   120

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

   121

    for varlist in configuration.getGlobalVars():

   122

        config += "  VAR_GLOBAL"

   123

        if varlist.getRetain():

   124

            config += " RETAIN"

   125

        if varlist.getConstant():

   126

            config += " CONSTANT"

   127

        config += "\n"

   128

        for var in varlist.getVariable():

   129

            vartype_content = var.getType().getContent()

   135

                var_type = vartype_content["name"]

   136

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

   137

            address = var.getAddress()

   138

            if address:

   139

                config += "AT %s "%address

   140

            config += ": %s"%var_type

   141

            initial = var.getInitialValue()

   142

            if initial:

   143

                value = str(initial.getValue())

   144

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

   145

                if var_type == "STRING":

   146

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

   147

                elif var_type == "WSTRING":

   148

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

   149

                else:

   150

                    config += " := %s"%value

   151

            config += ";\n"

   152

        config += "  END_VAR\n"

   153

    for resource in configuration.getResource():

   154

        config += GenerateResource(resource)

   155

    config += "END_CONFIGURATION\n"

   156

    return config

   157

   158

def GenerateResource(resource):

   159

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

   160

    for varlist in resource.getGlobalVars():

   161

        resrce += "    VAR_GLOBAL"

   162

        if varlist.getRetain():

   163

            resrce += " RETAIN"

   164

        if varlist.getConstant():

   165

            resrce += " CONSTANT"

   166

        resrce += "\n"

   167

        for var in varlist.getVariable():

   168

            vartype_content = var.getType().getContent()

   174

                var_type = vartype_content["name"]

   175

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

   176

            address = var.getAddress()

   177

            if address:

   178

                resrce += "AT %s "%address

   179

            resrce += ": %s"%var_type

   180

            initial = var.getInitialValue()

   181

            if initial:

   182

                value = str(initial.getValue())

   183

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

   184

                if var_type == "STRING":

   185

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

   186

                elif var_type == "WSTRING":

   187

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

   188

                else:

   189

                    resrce += " := %s"%value

   190

            resrce += ";\n"

   191

        resrce += "    END_VAR\n"

   192

    tasks = resource.getTask()

   193

    for task in tasks:

   194

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

   195

        args = []

   196

        single = task.getSingle()

   197

        if single:

   198

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

   199

        interval = task.getInterval()

   200

        if interval:

   201

            text = "t#"

   202

            if interval.hour != 0:

   203

                text += "%dh"%interval.hour

   204

            if interval.minute != 0:

   205

                text += "%dm"%interval.minute

   206

            if interval.second != 0:

   207

                text += "%ds"%interval.second

   208

            if interval.microsecond != 0:

   209

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

   210

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

   211

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

   212

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

   213

    for task in tasks:

   214

        for instance in task.getPouInstance():

   215

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

   216

    for instance in resource.getPouInstance():

   217

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

   218

    resrce += "  END_RESOURCE\n"

   219

    return resrce

   220

   221

"""

   222

Module implementing methods for generating PLC programs in ST or IL

   223

"""

   224

   225

class PouProgram:

   226

   227

    def __init__(self, name, type):

   228

        self.Name = name

   229

        self.Type = type

   230

        self.ReturnType = None

   231

        self.Interface = []

   232

        self.InitialSteps = []

   233

        self.ComputedBlocks = {}

   234

        self.ComputedConnectors = {}

   235

        self.ConnectionTypes = {}

   236

        self.RelatedConnections = []

   237

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

   238

        self.SFCComputedBlocks = ""

   239

        self.ActionNumber = 0

   240

        self.Program = ""

   241

   242

    def GetActionNumber(self):

   243

        self.ActionNumber += 1

   244

        return self.ActionNumber

   245

   246

    def IsAlreadyDefined(self, name):

   247

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

   248

            for var_type, var_name, var_address, var_initial in vars:

   249

                if name == var_name:

   250

                    return True

   251

        return False

   252

   253

    def GetVariableType(self, name):

   254

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

   255

            for var_type, var_name, var_address, var_initial in vars:

   256

                if name == var_name:

   257

                    return var_type

   258

        return None

   259

   260

    def GetConnectedConnection(self, connection, body):

   261

        links = connection.getConnections()

   262

        if links and len(links) == 1:

   263

            return self.GetLinkedConnection(links[0], body)

   264

        return None

   265

   266

    def GetLinkedConnection(self, link, body):

   267

        parameter = link.getFormalParameter()

   268

        instance = body.getContentInstance(link.getRefLocalId())

   269

        if isinstance(instance, (plcopen.inVariable, plcopen.inOutVariable, plcopen.continuation, plcopen.contact, plcopen.coil)):

   270

            return instance.connectionPointOut

   271

        elif isinstance(instance, plcopen.block):

   272

            outputvariables = instance.outputVariables.getVariable()

   273

            if len(outputvariables) == 1:

   274

                return outputvariables[0].connectionPointOut

   275

            elif parameter:

   276

                for variable in outputvariables:

   277

                    if variable.getFormalParameter() == parameter:

   278

                        return variable.connectionPointOut

   279

            else:

   280

                point = link.getPosition()[-1]

   281

                for variable in outputvariables:

   282

                    relposition = variable.connectionPointOut.getRelPosition()

   283

                    blockposition = instance.getPosition()

   284

                    if point.x == blockposition.x + relposition[0] and point.y == blockposition.y + relposition[1]:

   285

                        return variable.connectionPointOut

   286

        elif isinstance(instance, plcopen.leftPowerRail):

   287

            outputconnections = instance.getConnectionPointOut()

   288

            if len(outputconnections) == 1:

   289

                return outputconnections[0]

   290

            else:

   291

                point = link.getPosition()[-1]

   292

                for outputconnection in outputconnections:

   293

                    relposition = outputconnection.getRelPosition()

   294

                    powerrailposition = instance.getPosition()

   295

                    if point.x == powerrailposition.x + relposition[0] and point.y == powerrailposition.y + relposition[1]:

   296

                        return outputconnection

   297

        return None

   298

   299

    def ExtractRelatedConnections(self, connection):

   300

        for i, related in enumerate(self.RelatedConnections):

   301

            if connection in related:

   302

                return self.RelatedConnections.pop(i)

   303

        return [connection]

   304

   305

    def GenerateInterface(self, interface):

   306

        if self.Type == "FUNCTION":

   307

            returntype_content = interface.getReturnType().getContent()

   308

            if returntype_content["value"] is None:

   309

                self.ReturnType = returntype_content["name"]

   310

            else:

   311

                self.ReturnType = returntype_content["value"].getName()

   312

        for varlist in interface.getContent():

   313

            variables = []

   314

            located = False

   315

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

   316

                vartype_content = var.getType().getContent()

   318

                    var_type = vartype_content["value"].getName()

   319

                    GeneratePouProgram(var_type)

   320

                    blocktype = GetBlockType(var_type)

   321

                    if blocktype is not None:

   322

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

   323

                        located = False

   324

                    else:

   325

                        initial = var.getInitialValue()

   326

                        if initial:

   327

                            initial_value = initial.getValue()

   328

                        else:

   329

                            initial_value = None

   330

                        address = var.getAddress()

   331

                        if address:

   332

                            located = True

   333

                        variables.append((vartype_content["value"].getName(), var.getName(), address, initial_value))

   347

            if len(variables) > 0:

   348

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

   349

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

   350

   351

    def GenerateConnectionTypes(self, pou):

   352

        body = pou.getBody()

   353

        body_content = body.getContent()

   354

        body_type = body_content["name"]

   355

        if body_type in ["FBD", "LD", "SFC"]:

   356

            for instance in body.getContentInstances():

   357

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

   358

                    expression = instance.getExpression()

   359

                    var_type = self.GetVariableType(expression)

   360

                    if expression == pou.getName():

   361

                        returntype_content = pou.interface.getReturnType().getContent()

   367

                            var_type = returntype_content["name"]

   368

                    elif var_type is None:

   369

                        var_type = expression.split("#")[0]

   370

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

   371

                        self.ConnectionTypes[instance.connectionPointOut] = var_type

   372

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

   373

                        self.ConnectionTypes[instance.connectionPointIn] = var_type

   374

                        connected = self.GetConnectedConnection(instance.connectionPointIn, body)

   375

                        if connected and connected not in self.ConnectionTypes:

   376

                            for connection in self.ExtractRelatedConnections(connected):

   377

                                self.ConnectionTypes[connection] = var_type

   378

                elif isinstance(instance, (plcopen.contact, plcopen.coil)):

   379

                    self.ConnectionTypes[instance.connectionPointOut] = "BOOL"

   380

                    self.ConnectionTypes[instance.connectionPointIn] = "BOOL"

   381

                    connected = self.GetConnectedConnection(instance.connectionPointIn, body)

   382

                    if connected and connected not in self.ConnectionTypes:

   383

                        for connection in self.ExtractRelatedConnections(connected):

   384

                            self.ConnectionTypes[connection] = "BOOL"

   385

                elif isinstance(instance, plcopen.leftPowerRail):

   386

                    for connection in instance.getConnectionPointOut():

   387

                        self.ConnectionTypes[connection] = "BOOL"

   388

                elif isinstance(instance, plcopen.rightPowerRail):

   389

                    for connection in instance.getConnectionPointIn():

   390

                        self.ConnectionTypes[connection] = "BOOL"

   391

                        connected = self.GetConnectedConnection(connection, body)

   392

                        if connected and connected not in self.ConnectionTypes:

   393

                            for connection in self.ExtractRelatedConnections(connected):

   394

                                self.ConnectionTypes[connection] = "BOOL"

   395

                elif isinstance(instance, plcopen.transition):

   396

                    content = instance.condition.getContent()

   397

                    if content["name"] == "connection" and len(content["value"]) == 1:

   398

                        connected = self.GetLinkedConnection(content["value"][0], body)

   399

                        if connected and connected not in self.ConnectionTypes:

   400

                            for connection in self.ExtractRelatedConnections(connected):

   401

                                self.ConnectionTypes[connection] = "BOOL"

   402

                elif isinstance(instance, plcopen.block):

   403

                    block_infos = GetBlockType(instance.getTypeName())

   404

                    undefined = {}

   405

                    for variable in instance.outputVariables.getVariable():

   406

                        output_name = variable.getFormalParameter()

   407

                        for oname, otype, oqualifier in block_infos["outputs"]:

   408

                            if output_name == oname and variable.connectionPointOut not in self.ConnectionTypes:

   409

                                if otype.startswith("ANY"):

   410

                                    if otype not in undefined:

   411

                                        undefined[otype] = []

   412

                                    undefined[otype].append(variable.connectionPointOut)

   413

                                else:

   414

                                    for connection in self.ExtractRelatedConnections(variable.connectionPointOut):

   415

                                        self.ConnectionTypes[connection] = otype

   416

                    for variable in instance.inputVariables.getVariable():

   417

                        input_name = variable.getFormalParameter()

   418

                        for iname, itype, iqualifier in block_infos["inputs"]:

   419

                            if input_name == iname:

   420

                                connected = self.GetConnectedConnection(variable.connectionPointIn, body)

   421

                                if itype.startswith("ANY"):

   422

                                    if itype not in undefined:

   423

                                        undefined[itype] = []

   424

                                    undefined[itype].append(variable.connectionPointIn)

   425

                                    if connected:

   426

                                        undefined[itype].append(connected)

   427

                                else:

   428

                                    self.ConnectionTypes[variable.connectionPointIn] = itype

   429

                                    if connected and connected not in self.ConnectionTypes:

   430

                                        for connection in self.ExtractRelatedConnections(connected):

   431

                                            self.ConnectionTypes[connection] = itype

   432

                    for var_type, connections in undefined.items():

   433

                        related = []

   434

                        for connection in connections:

   435

                            if connection in self.ConnectionTypes:

   436

                                var_type = self.ConnectionTypes[connection]

   437

                            else:

   438

                                related.extend(self.ExtractRelatedConnections(connection))

   439

                        if var_type.startswith("ANY") and len(related) > 0:

   440

                            self.RelatedConnections.append(related)

   441

                        else:

   442

                            for connection in related:

   443

                                self.ConnectionTypes[connection] = var_type

   444

   445

    def GenerateProgram(self, pou):

   446

        body = pou.getBody()

   447

        body_content = body.getContent()

   448

        body_type = body_content["name"]

   449

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

   450

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

   451

        elif body_type == "FBD":

   452

            orderedInstances = []

   453

            otherInstances = []

   454

            for instance in body.getContentInstances():

   455

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

   456

                    executionOrderId = instance.getExecutionOrderId()

   457

                    if executionOrderId > 0:

   458

                        orderedInstances.append((executionOrderId, instance))

   459

                    else:

   460

                        otherInstances.append(instance)

   461

                elif isinstance(instance, plcopen.connector):

   462

                    otherInstances.append(instance)

   463

            orderedInstances.sort()

   464

            instances = [instance for (executionOrderId, instance) in orderedInstances] + otherInstances

   465

            for instance in instances:

   466

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

   467

                    var = instance.getExpression()

   468

                    connections = instance.connectionPointIn.getConnections()

   469

                    if connections and len(connections) == 1:

   470

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

   471

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

   472

                elif isinstance(instance, plcopen.block):

   473

                    block_type = instance.getTypeName()

   474

                    self.GeneratePouProgram(block_type)

   475

                    block_infos = GetBlockType(block_type)

   476

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

   477

                elif isinstance(instance, plcopen.connector):

   478

                    connector = instance.getName()

   479

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

   480

                        continue 

   481

                    connections = instance.connectionPointIn.getConnections()

   482

                    if connections and len(connections) == 1:

   483

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

   484

        elif body_type == "LD":

   485

            for instance in body.getContentInstances():

   486

                if isinstance(instance, plcopen.coil):

   487

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

   488

                    if len(paths) > 0:

   489

                        paths = tuple(paths)

   490

                    else:

   491

                        paths = paths[0] 

   492

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

   493

                    expression = self.ComputeLDExpression(paths, True)

   494

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

   495

        elif body_type == "SFC":