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

class PLCGenException(Exception):

    41

    pass

    42

    43

def ReIndentText(text, nb_spaces):

    44

    compute = ""

    45

    lines = text.splitlines()

    46

    if len(lines) > 0:

    47

        line_num = 0

    48

        while line_num < len(lines) and len(lines[line_num].strip()) == 0:

    49

            line_num += 1

    50

        if line_num < len(lines):

    51

            spaces = 0

    52

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

    53

                spaces += 1

    54

            indent = ""

    55

            for i in xrange(spaces, nb_spaces):

    56

                indent += " "

    57

            for line in lines:

    58

                if line != "":

    59

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

    60

                else:

    61

                    compute += "\n"

    62

    return compute

    63

    64

def GenerateDataType(datatype_name):

    65

    if not datatypeComputed.get(datatype_name, True):

    66

        datatypeComputed[datatype_name] = True

    67

        global currentProject, currentProgram

    68

        datatype = currentProject.getdataType(datatype_name)

    69

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

    70

        basetype_content = datatype.baseType.getcontent()

    71

        if basetype_content["name"] in ["string", "wstring"]:

    72

            datatype_def += " %s"%basetype_content["name"].upper()

    73

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

    74

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

    75

            GenerateDataType(basetype_name)

    76

            datatype_def += " %s"%basetype_name

    77

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

    78

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

    79

            if base_type["name"] == "derived":

    80

                basetype_name = base_type["value"].getname()

    81

            else:

    82

                basetype_name = base_type["name"]

    83

                GenerateDataType(basetype_name)

    84

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

    85

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

    86

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

    87

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

    88

            values = []

    89

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

    90

                values.append(value.getname())

    91

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

    92

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

    93

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

    94

            if base_type["name"] == "derived":

    95

                basetype_name = base_type["value"].getname()

    96

            elif base_type["name"] in ["string", "wstring"]:

    97

                basetype_name = base_type["name"].upper()

    98

            else:

    99

                basetype_name = base_type["name"]

   100

                GenerateDataType(basetype_name)

   101

            dimensions = []

   102

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

   103

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

   104

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

   105

        else:

   106

            datatype_def += " %s"%basetype_content["name"]

   107

        if datatype.initialValue is not None:

   108

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

   109

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

   110

   111

def GeneratePouProgram(pou_name):

   112

    if not pouComputed.get(pou_name, True):

   113

        pouComputed[pou_name] = True

   114

        global currentProject, currentProgram

   115

        pou = currentProject.getpou(pou_name)

   116

        pou_type = pou.getpouType()

   117

        if pou_type in pouTypeNames:

   118

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

   119

        else:

   120

            raise PLCGenException, "Undefined pou type"

   121

        pou_program.GenerateInterface(pou)

   122

        pou_program.GenerateConnectionTypes(pou)

   123

        pou_program.GenerateProgram(pou)

   124

        currentProgram += pou_program.GenerateSTProgram()

   125

   126

def GenerateConfiguration(configuration):

   127

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

   128

    for varlist in configuration.getglobalVars():

   129

        config += "  VAR_GLOBAL"

   130

        if varlist.getretain():

   131

            config += " RETAIN"

   132

        if varlist.getconstant():

   133

            config += " CONSTANT"

   134

        config += "\n"

   135

        for var in varlist.getvariable():

   136

            vartype_content = var.gettype().getcontent()

   137

            if vartype_content["name"] == "derived":

   138

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

   139

            elif vartype_content["name"] in ["string", "wstring"]:

   140

                var_type = vartype_content["name"].upper()

   141

            else:

   142

                var_type = vartype_content["name"]

   143

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

   144

            address = var.getaddress()

   145

            if address:

   146

                config += "AT %s "%address

   147

            config += ": %s"%var_type

   148

            initial = var.getinitialValue()

   149

            if initial:

   150

                value = str(initial.getvalue())

   151

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

   152

                if var_type == "STRING":

   153

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

   154

                elif var_type == "WSTRING":

   155

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

   156

                else:

   157

                    config += " := %s"%value

   158

            config += ";\n"

   159

        config += "  END_VAR\n"

   160

    for resource in configuration.getresource():

   161

        config += GenerateResource(resource)

   162

    config += "END_CONFIGURATION\n"

   163

    return config

   164

   165

def GenerateResource(resource):

   166

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

   167

    for varlist in resource.getglobalVars():

   168

        resrce += "    VAR_GLOBAL"

   169

        if varlist.getretain():

   170

            resrce += " RETAIN"

   171

        if varlist.getconstant():

   172

            resrce += " CONSTANT"

   173

        resrce += "\n"

   174

        for var in varlist.getvariable():

   175

            vartype_content = var.gettype().getcontent()

   176

            if vartype_content["name"] == "derived":

   177

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

   178

            elif vartype_content["name"] in ["string", "wstring"]:

   179

                var_type = vartype_content["name"].upper()

   180

            else:

   181

                var_type = vartype_content["name"]

   182

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

   183

            address = var.getaddress()

   184

            if address:

   185

                resrce += "AT %s "%address

   186

            resrce += ": %s"%var_type

   187

            initial = var.getinitialValue()

   188

            if initial:

   189

                value = str(initial.getvalue())

   190

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

   191

                if var_type == "STRING":

   192

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

   193

                elif var_type == "WSTRING":

   194

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

   195

                else:

   196

                    resrce += " := %s"%value

   197

            resrce += ";\n"

   198

        resrce += "    END_VAR\n"

   199

    tasks = resource.gettask()

   200

    for task in tasks:

   201

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

   202

        args = []

   203

        single = task.getsingle()

   204

        if single:

   205

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

   206

        interval = task.getinterval()

   207

        if interval:

   208

            text = "t#"

   209

            if interval.hour != 0:

   210

                text += "%dh"%interval.hour

   211

            if interval.minute != 0:

   212

                text += "%dm"%interval.minute

   213

            if interval.second != 0:

   214

                text += "%ds"%interval.second

   215

            if interval.microsecond != 0:

   216

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

   217

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

   218

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

   219

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

   220

    for task in tasks:

   221

        for instance in task.getpouInstance():

   222

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

   223

    for instance in resource.getpouInstance():

   224

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

   225

    resrce += "  END_RESOURCE\n"

   226

    return resrce

   227

   228

"""

   229

Module implementing methods for generating PLC programs in ST or IL

   230

"""

   231

   232

class PouProgram:

   233

   234

    def __init__(self, name, type):

   235

        self.Name = name

   236

        self.Type = type

   237

        self.ReturnType = None

   238

        self.Interface = []

   239

        self.InitialSteps = []

   240

        self.ComputedBlocks = {}

   241

        self.ComputedConnectors = {}

   242

        self.ConnectionTypes = {}

   243

        self.RelatedConnections = []

   244

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

   245

        self.SFCComputedBlocks = ""

   246

        self.ActionNumber = 0

   247

        self.Program = ""

   248

   249

    def GetActionNumber(self):

   250

        self.ActionNumber += 1

   251

        return self.ActionNumber

   252

   253

    def IsAlreadyDefined(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 True

   258

        return False

   259

   260

    def GetVariableType(self, name):

   261

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

   262

            for var_type, var_name, var_address, var_initial in vars:

   263

                if name == var_name:

   264

                    return var_type

   265

        return None

   266

   267

    def GetConnectedConnection(self, connection, body):

   268

        links = connection.getconnections()

   269

        if links and len(links) == 1:

   270

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

   271

        return None

   272

   273

    def GetLinkedConnection(self, link, body):

   274

        parameter = link.getformalParameter()

   275

        instance = body.getcontentInstance(link.getrefLocalId())

   276

        if isinstance(instance, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_inOutVariable, plcopen.commonObjects_continuation, plcopen.ldObjects_contact, plcopen.ldObjects_coil)):

   277

            return instance.connectionPointOut

   278

        elif isinstance(instance, plcopen.fbdObjects_block):

   279

            outputvariables = instance.outputVariables.getvariable()

   280

            if len(outputvariables) == 1:

   281

                return outputvariables[0].connectionPointOut

   282

            elif parameter:

   283

                for variable in outputvariables:

   284

                    if variable.getformalParameter() == parameter:

   285

                        return variable.connectionPointOut

   286

            else:

   287

                point = link.getPosition()[-1]

   288

                for variable in outputvariables:

   289

                    relposition = variable.connectionPointOut.getrelPositionXY()

   290

                    blockposition = instance.getposition()

   291

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

   292

                        return variable.connectionPointOut

   293

        elif isinstance(instance, plcopen.ldObjects_leftPowerRail):

   294

            outputconnections = instance.getconnectionPointOut()

   295

            if len(outputconnections) == 1:

   296

                return outputconnections[0]

   297

            else:

   298

                point = link.getposition()[-1]

   299

                for outputconnection in outputconnections:

   300

                    relposition = outputconnection.getrelPositionXY()

   301

                    powerrailposition = instance.getposition()

   302

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

   303

                        return outputconnection

   304

        return None

   305

   306

    def ExtractRelatedConnections(self, connection):

   307

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

   308

            if connection in related:

   309

                return self.RelatedConnections.pop(i)

   310

        return [connection]

   311

   312

    def GenerateInterface(self, pou):

   313

        interface = pou.getinterface()

   314

        if interface is not None:

   315

            body = pou.getbody()

   316

            body_content = body.getcontent()

   317

            if self.Type == "FUNCTION":

   318

                returntype_content = interface.getreturnType().getcontent()

   319

                if returntype_content["value"] is None:

   320

                    self.ReturnType = returntype_content["name"]

   321

                else:

   322

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

   323

            for varlist in interface.getcontent():

   324

                variables = []

   325

                located = []

   326

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

   327

                    vartype_content = var.gettype().getcontent()

   328

                    if vartype_content["name"] == "derived":

   329

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

   330

                        GeneratePouProgram(var_type)

   331

                        blocktype = GetBlockType(var_type)

   332

                        if blocktype is not None:

   333

                            if body_content["name"] in ["FBD", "LD", "SFC"]:

   334

                                block = pou.getinstanceByName(var.getname())

   335

                            else:

   336

                                block = None

   337

                            for variable in blocktype["initialise"](var_type, var.getname(), block):

   338

                                if variable[2] is not None:

   339

                                    located.append(variable)

   340

                                else:

   341

                                    variables.append(variable)

   342

                        else:

   343

                            initial = var.getinitialValue()

   344

                            if initial:

   345

                                initial_value = initial.getvalue()

   346

                            else:

   347

                                initial_value = None

   348

                            address = var.getaddress()

   349

                            if address is not None:

   350

                                located.append((vartype_content["value"].getname(), var.getname(), address, initial_value))

   351

                            else:

   352

                                variables.append((vartype_content["value"].getname(), var.getname(), None, initial_value))

   353

                    else:

   354

                        initial = var.getinitialValue()

   355

                        if initial:

   356

                            initial_value = initial.getvalue()

   357

                        else:

   358

                            initial_value = None

   359

                        address = var.getaddress()

   360

                        if vartype_content["name"] in ["string", "wstring"]:

   361

                            if address is not None:

   362

                                located.append((vartype_content["name"].upper(), var.getname(), address, initial_value))

   363

                            else:

   364

                                variables.append((vartype_content["name"].upper(), var.getname(), None, initial_value))

   365

                        elif address is not None:

   366

                            located.append((vartype_content["name"], var.getname(), address, initial_value))

   367

                        else:

   368

                            variables.append((vartype_content["name"], var.getname(), None, initial_value))

   369

                if len(variables) > 0:

   370

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

   371

                                varlist["value"].getconstant(), False, variables))

   372

                if len(located) > 0:

   373

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

   374

                                varlist["value"].getconstant(), True, located))

   375

   376

    def GenerateConnectionTypes(self, pou):

   377

        body = pou.getbody()

   378

        body_content = body.getcontent()

   379

        body_type = body_content["name"]

   380

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

   381

            for instance in body.getcontentInstances():

   382

                if isinstance(instance, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable)):

   383

                    expression = instance.getexpression()

   384

                    var_type = self.GetVariableType(expression)

   385

                    if expression == pou.getname():

   386

                        returntype_content = pou.interface.getreturnType().getcontent()

   387

                        if returntype_content["name"] == "derived":

   388

                            var_type = returntype_content["value"].getname()

   389

                        elif returntype_content["name"] in ["string", "wstring"]:

   390

                            var_type = returntype_content["name"].upper()

   391

                        else:

   392

                            var_type = returntype_content["name"]

   393

                    elif var_type is None:

   394

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

   395

                    if isinstance(instance, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_inOutVariable)):

   396

                        self.ConnectionTypes[instance.connectionPointOut] = var_type

   397

                    if isinstance(instance, (plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable)):

   398

                        self.ConnectionTypes[instance.connectionPointIn] = var_type

   399

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

   400

                        if connected and connected not in self.ConnectionTypes:

   401

                            for connection in self.ExtractRelatedConnections(connected):

   402

                                self.ConnectionTypes[connection] = var_type

   403

                elif isinstance(instance, (plcopen.ldObjects_contact, plcopen.ldObjects_coil)):

   404

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

   405

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

   406

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

   407

                    if connected and connected not in self.ConnectionTypes:

   408

                        for connection in self.ExtractRelatedConnections(connected):

   409

                            self.ConnectionTypes[connection] = "BOOL"

   410

                elif isinstance(instance, plcopen.ldObjects_leftPowerRail):

   411

                    for connection in instance.getconnectionPointOut():

   412

                        self.ConnectionTypes[connection] = "BOOL"

   413

                elif isinstance(instance, plcopen.ldObjects_rightPowerRail):

   414

                    for connection in instance.getconnectionPointIn():

   415

                        self.ConnectionTypes[connection] = "BOOL"

   416

                        connected = self.GetConnectedConnection(connection, body)

   417

                        if connected and connected not in self.ConnectionTypes:

   418

                            for connection in self.ExtractRelatedConnections(connected):

   419

                                self.ConnectionTypes[connection] = "BOOL"

   420

                elif isinstance(instance, plcopen.sfcObjects_transition):

   421

                    content = instance.condition.getcontent()

   422

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

   423

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

   424

                        if connected and connected not in self.ConnectionTypes:

   425

                            for connection in self.ExtractRelatedConnections(connected):

   426

                                self.ConnectionTypes[connection] = "BOOL"

   427

                elif isinstance(instance, plcopen.fbdObjects_block):

   428

                    block_infos = GetBlockType(instance.gettypeName())

   429

                    undefined = {}

   430

                    for variable in instance.outputVariables.getvariable():

   431

                        output_name = variable.getformalParameter()

   432

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

   433

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

   434

                                if otype.startswith("ANY"):

   435

                                    if otype not in undefined:

   436

                                        undefined[otype] = []

   437

                                    undefined[otype].append(variable.connectionPointOut)

   438

                                else:

   439

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

   440

                                        self.ConnectionTypes[connection] = otype

   441

                    for variable in instance.inputVariables.getvariable():

   442

                        input_name = variable.getformalParameter()

   443

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

   444

                            if input_name == iname:

   445

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

   446

                                if itype.startswith("ANY"):

   447

                                    if itype not in undefined:

   448

                                        undefined[itype] = []

   449

                                    undefined[itype].append(variable.connectionPointIn)

   450

                                    if connected:

   451

                                        undefined[itype].append(connected)

   452

                                else:

   453

                                    self.ConnectionTypes[variable.connectionPointIn] = itype

   454

                                    if connected and connected not in self.ConnectionTypes:

   455

                                        for connection in self.ExtractRelatedConnections(connected):

   456

                                            self.ConnectionTypes[connection] = itype

   457

                    for var_type, connections in undefined.items():

   458

                        related = []

   459

                        for connection in connections:

   460

                            if connection in self.ConnectionTypes:

   461

                                var_type = self.ConnectionTypes[connection]

   462

                            else:

   463

                                related.extend(self.ExtractRelatedConnections(connection))

   464

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

   465

                            self.RelatedConnections.append(related)

   466

                        else:

   467

                            for connection in related:

   468

                                self.ConnectionTypes[connection] = var_type

   469

   470

    def GenerateProgram(self, pou):

   471

        body = pou.getbody()

   472

        body_content = body.getcontent()

   473

        body_type = body_content["name"]

   474

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

   475

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

   476

        elif body_type == "FBD":

   477

            orderedInstances = []

   479

            for instance in body.getcontentInstances():

   480

                if isinstance(instance, (plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable, plcopen.fbdObjects_block)):

   481

                    executionOrderId = instance.getexecutionOrderId()

   482

                    if executionOrderId > 0:

   483

                        orderedInstances.append((executionOrderId, instance))

   488