1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

import string, os, sys

     5

     6

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     7

#based on the plcopen standard. 

     8

#

     9

#Copyright (C): Edouard TISSERANT and Laurent BESSARD

    10

#

    11

#See COPYING file for copyrights details.

    12

#

    13

#This library is free software; you can redistribute it and/or

    14

#modify it under the terms of the GNU General Public

    15

#License as published by the Free Software Foundation; either

    16

#version 2.1 of the License, or (at your option) any later version.

    17

#

    18

#This library is distributed in the hope that it will be useful,

    19

#but WITHOUT ANY WARRANTY; without even the implied warranty of

    20

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    21

#Lesser General Public License for more details.

    22

#

    23

#You should have received a copy of the GNU General Public

    24

#License along with this library; if not, write to the Free Software

    25

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    26

    27

    28

LANGUAGES = ["IL","ST","FBD","LD","SFC"]

    29

    31

#-------------------------------------------------------------------------------

    32

#                        Function Block Types definitions

    33

#-------------------------------------------------------------------------------

    34

    36

"""

    37

Ordored list of common Function Blocks defined in the IEC 61131-3

    38

Each block have this attributes:

    39

    - "name" : The block name

    40

    - "type" : The block type. It can be "function", "functionBlock" or "program"

    41

    - "extensible" : Boolean that define if the block is extensible

    42

    - "inputs" : List of the block inputs

    43

    - "outputs" : List of the block outputs

    44

    - "comment" : Comment that will be displayed in the block popup

    45

Inputs and outputs are a tuple of characteristics that are in order:

    46

    - The name

    47

    - The data type

    48

    - The default modifier which can be "none", "negated", "rising" or "falling"

    49

"""

    50

    51

BlockTypes = [{"name" : "Standard function blocks", "list":

    52

               [{"name" : "SR", "type" : "functionBlock", "extensible" : False, 

    53

                    "inputs" : [("S1","BOOL","none"),("R","BOOL","none")], 

    54

                    "outputs" : [("Q1","BOOL","none")],

    55

                    "comment" : "SR bistable\nThe SR bistable is a latch where the Set dominates."},

    56

                {"name" : "RS", "type" : "functionBlock", "extensible" : False, 

    57

                    "inputs" : [("S","BOOL","none"),("R1","BOOL","none")], 

    58

                    "outputs" : [("Q1","BOOL","none")],

    59

                    "comment" : "RS bistable\nThe RS bistable is a latch where the Reset dominates."},

    60

                {"name" : "SEMA", "type" : "functionBlock", "extensible" : False, 

    61

                    "inputs" : [("CLAIM","BOOL","none"),("RELEASE","BOOL","none")], 

    62

                    "outputs" : [("BUSY","BOOL","none")],

    63

                    "comment" : "Semaphore\nThe semaphore provides a mechanism to allow software elements mutually exclusive access to certain ressources."},

    64

                {"name" : "R_TRIG", "type" : "functionBlock", "extensible" : False, 

    65

                    "inputs" : [("CLK","BOOL","none")], 

    66

                    "outputs" : [("Q","BOOL","none")],

    67

                    "comment" : "Rising edge detector\nThe output produces a single pulse when a rising edge is detected."},

    68

                {"name" : "F_TRIG", "type" : "functionBlock", "extensible" : False, 

    69

                    "inputs" : [("CLK","BOOL","none")], 

    70

                    "outputs" : [("Q","BOOL","none")],

    71

                    "comment" : "Falling edge detector\nThe output produces a single pulse when a falling edge is detected."},

    72

                {"name" : "CTU", "type" : "functionBlock", "extensible" : False, 

    73

                    "inputs" : [("CU","BOOL","rising"),("R","BOOL","none"),("PV","INT","none")], 

    74

                    "outputs" : [("Q","BOOL","none"),("CV","INT","none")],

    75

                    "comment" : "Up-counter\nThe up-counter can be used to signal when a count has reached a maximum value."},

    76

                {"name" : "CTD", "type" : "functionBlock", "extensible" : False, 

    77

                    "inputs" : [("CD","BOOL","rising"),("LD","BOOL","none"),("PV","INT","none")], 

    78

                    "outputs" : [("Q","BOOL","none"),("CV","INT","none")],

    79

                    "comment" : "Down-counter\nThe down-counter can be used to signal when a count has reached zero, on counting down from a preset value."},

    80

                {"name" : "CTUD", "type" : "functionBlock", "extensible" : False, 

    81

                    "inputs" : [("CU","BOOL","rising"),("CD","BOOL","rising"),("R","BOOL","none"),("LD","BOOL","none"),("PV","INT","none")], 

    82

                    "outputs" : [("QU","BOOL","none"),("QD","BOOL","none"),("CV","INT","none")],

    83

                    "comment" : "Up-down counter\nThe up-down counter has two inputs CU and CD. It can be used to both count up on one input ans down on the other."},

    84

                {"name" : "TP", "type" : "functionBlock", "extensible" : False, 

    85

                    "inputs" : [("IN","BOOL","none"),("PT","TIME","none")], 

    86

                    "outputs" : [("Q","BOOL","none"),("ET","TIME","none")],

    87

                    "comment" : "Pulse timer\nThe pulse timer can be used to generate output pulses of a given time duration."},

    88

                {"name" : "TOF", "type" : "functionBlock", "extensible" : False, 

    89

                    "inputs" : [("IN","BOOL","none"),("PT","TIME","none")], 

    90

                    "outputs" : [("Q","BOOL","none"),("ET","TIME","none")],

    91

                    "comment" : "On-delay timer\nThe on-delay timer can be used to delay setting an output true, for fixed period after an input becomes true."},

    92

                {"name" : "TON", "type" : "functionBlock", "extensible" : False, 

    93

                    "inputs" : [("IN","BOOL","none"),("PT","TIME","none")], 

    94

                    "outputs" : [("Q","BOOL","none"),("ET","TIME","none")],

    95

                    "comment" : "Off-delay timer\nThe off-delay timer can be used to delay setting an output false, for fixed period after input goes false."},

    96

                {"name" : "RTC", "type" : "functionBlock", "extensible" : False, 

    97

                    "inputs" : [("EN","BOOL","none"),("PDT","DATE_AND_TIME","none")], 

    98

                    "outputs" : [("Q","BOOL","none"),("CDT","DATE_AND_TIME","none")],

    99

                    "comment" : "Real time clock\nThe real time clock has many uses including time stamping, setting dates and times of day in batch reports, in alarm messages and so on."},

   100

                {"name" : "INTEGRAL", "type" : "functionBlock", "extensible" : False, 

   101

                    "inputs" : [("RUN","BOOL","none"),("R1","BOOL","none"),("XIN","REAL","none"),("X0","REAL","none"),("CYCLE","TIME","none")], 

   102

                    "outputs" : [("Q","BOOL","none"),("XOUT","REAL","none")],

   103

                    "comment" : "Integral\nThe integral function block integrates the value of input XIN over time."},

   104

                {"name" : "DERIVATIVE", "type" : "functionBlock", "extensible" : False, 

   105

                    "inputs" : [("RUN","BOOL","none"),("XIN","REAL","none"),("CYCLE","TIME","none")], 

   106

                    "outputs" : [("XOUT","REAL","none")],

   107

                    "comment" : "Derivative\nThe derivative function block produces an output XOUT proportional to the rate of change of the input XIN."},

   108

                {"name" : "PID", "type" : "functionBlock", "extensible" : False, 

   109

                    "inputs" : [("AUTO","BOOL","none"),("PV","REAL","none"),("SP","REAL","none"),("X0","REAL","none"),("KP","REAL","none"),("TR","REAL","none"),("TD","REAL","none"),("CYCLE","TIME","none")], 

   110

                    "outputs" : [("XOUT","REAL","none")],

   111

                    "comment" : "PID\nThe PID (proportional, Integral, Derivative) function block provides the classical three term controller for closed loop control."},

   112

                {"name" : "RAMP", "type" : "functionBlock", "extensible" : False, 

   113

                    "inputs" : [("RUN","BOOL","none"),("X0","REAL","none"),("X1","REAL","none"),("TR","TIME","none"),("CYCLE","TIME","none"),("HOLDBACK","BOOL","none"),("ERROR","REAL","none"),("PV","REAL","none")], 

   114

                    "outputs" : [("RAMP","BOOL","none"),("XOUT","REAL","none")],

   115

                    "comment" : "Ramp\nThe RAMP function block is modelled on example given in the standard but with the addition of a 'Holdback' feature."},

   116

                {"name" : "HYSTERESIS", "type" : "functionBlock", "extensible" : False, 

   117

                    "inputs" : [("XIN1","REAL","none"),("XIN2","REAL","none"),("EPS","REAL","none")], 

   118

                    "outputs" : [("Q","BOOL","none")],

   119

                    "comment" : "Hysteresis\nThe hysteresis function block provides a hysteresis boolean output driven by the difference of two floating point (REAL) inputs XIN1 and XIN2."},

   120

                {"name" : "RATIO_MONITOR", "type" : "functionBlock", "extensible" : False, 

   121

                    "inputs" : [("PV1","REAL","none"),("PV2","REAL","none"),("RATIO","REAL","none"),("TIMON","TIME","none"),("TIMOFF","TIME","none"),("TOLERANCE","BOOL","none"),("RESET","BOOL","none"),("CYCLE","TIME","none")], 

   122

                    "outputs" : [("ALARM","BOOL","none"),("TOTAL_ERR","BOOL","none")],

   123

                    "comment" : "Ratio monitor\nThe ratio_monitor function block checks that one process value PV1 is always a given ratio (defined by input RATIO) of a second process value PV2."},

   124

               ]}

   125

             ]

   126

   127

"""

   128

Function that returns the block definition associated to the block type given

   129

"""

   130

   131

def GetBlockType(type):

   132

    for category in BlockTypes:

   133

        for blocktype in category["list"]:

   134

            if blocktype["name"] == type:

   135

                return blocktype

   136

    return None

   137

   138

   139

#-------------------------------------------------------------------------------

   140

#                           Data Types definitions

   141

#-------------------------------------------------------------------------------

   142

   143

"""

   144

Ordored list of common data types defined in the IEC 61131-3

   145

Each type is associated to his direct parent type. It defines then a hierarchy

   146

between type that permits to make a comparison of two types

   147

"""

   148

TypeHierarchy_list = [

   152

	("ANY_MAGNITUDE", "ANY_ELEMENTARY"),

   180

   181

TypeHierarchy = dict(TypeHierarchy_list)

   182

   183

"""

   184

returns true if the given data type is the same that "reference" meta-type or one of its types.

   185

"""

   186

   187

def IsOfType(test, reference):

   188

    while test != None:

   189

        if test == reference:

   190

            return True

   191

        test = TypeHierarchy[test]

   192

    return False

   193

   194

"""

   195

returns list of all types that correspont to the ANY* meta type

   196

"""

   197

def GetSubTypes(reference):

   198

    return [ typename for typename in TypeHierarchy.iterkeys() if typename[:3] != "ANY" and IsOfType(typename, reference)]

   199

   200

   278

   279

   280

"""

   281

take a .csv file and translate it it a "csv_table"

   282

"""            

   283

def csv_file_to_table(file):

   284

	return [ map(string.strip,line.split(';')) for line in file.xreadlines()]

   285

   286

"""

   287

seek into the csv table to a section ( section_name match 1st field )

   288

return the matching row without first field

   289

"""

   290

def find_section(section_name, table):

   291

	fields = [None]

   292

	while(fields[0] != section_name):

   293

		fields = table.pop(0)

   294

	return fields[1:]

   295

   296

"""

   297

extract the standard functions standard parameter names and types...

   298

return a { ParameterName: Type, ...}

   299

"""

   300

def get_standard_funtions_input_variables(table):

   301

	variables = find_section("Standard_functions_variables_types", table)

   302

	standard_funtions_input_variables = {}

   303

	fields = [True,True]

   304

	while(fields[1]):

   305

		fields = table.pop(0)

   306

		variable_from_csv = dict([(champ, val) for champ, val in zip(variables, fields[1:]) if champ!=''])

   307

		standard_funtions_input_variables[variable_from_csv['name']] = variable_from_csv['type']

   308

	return standard_funtions_input_variables

   309

   310

"""

   311

translate .csv file input declaration into PLCOpenEditor interessting values

   312

in : "(ANY_NUM, ANY_NUM)" and { ParameterName: Type, ...}

   313

return [("IN1","ANY_NUM","none"),("IN2","ANY_NUM","none")] 

   314

"""

   315

def csv_input_translate(str_decl, variables, base):

   316

	decl = str_decl.replace('(','').replace(')','').replace(' ','').split(',')

   317

	param_types = []

   318

	param_names = []

   319

	modifiers = []

   320

   321

	len_of_not_predifined_variable = 0

   322

	for param_type in decl:

   323

		predifined_variable_param_type = variables.get(param_type,None)

   324

		if not predifined_variable_param_type :

   325

			len_of_not_predifined_variable += 1

   326

   327

	if len_of_not_predifined_variable>1 : suffix = str(base)

   328

	else: suffix = ''

   329

   330

	for param_type in decl:

   331

		predifined_variable_param_type = variables.get(param_type,None)

   332

		if predifined_variable_param_type :

   333

			param_types.append(predifined_variable_param_type)

   334

			param_names.append(param_type)

   335

		else:

   336

			param_types.append(param_type)

   337

			param_names.append("IN"+suffix)

   338

			base+=1

   339

			suffix = str(base)

   340

   341

	modifiers = ["none"]*len(param_types)

   342

	return zip(param_names,param_types,modifiers)

   343

   344

"""

   345

Fillin the PLCOpenEditor standard function dictionnary

   346

translate input and output declaration to something more pythonesque

   347

and add interface description to comment

   348

"""

   349

def decl_function(dico_from_table, variables):

   350

	Function_decl = { "type" : "function" }

   351

	for field, val in dico_from_table:

   352

		translate = {

   353

			"baseinputnumber" : lambda x:int(x),

   354

			"extensible" : lambda x: {"yes":True, "no":False}[x],

   355

			"inputs" : lambda x:csv_input_translate(x,variables,Function_decl.get("baseinputnumber",1)),

   356

			"outputs":lambda x:[("OUT",x,"none")]}

   357

		Function_decl[field] = translate.get(field,lambda x:x)(val)

   358

	return Function_decl

   359

   360

   361

def ANY_TO_ANY_FORMAT_GEN(fdecl):

   362

   363

	ANY_T0_ANY_LIST=[

   364

		(("ANY_NUM","ANY_BIT"),("ANY_NUM","ANY_BIT"), "(%(return_type)s)%(IN_value)s"),

   365

		(("ANY_NUM","ANY_BIT"),("ANY_DATE","TIME"), "(%(return_type)s)real_to_time(%(IN_value)s)"), 

   366

		(("ANY_DATE","TIME"), ("ANY_NUM","ANY_BIT"), "(%(return_type)s)time_to_real(%(IN_value)s)"), 

   367

		(("ANY_DATE","TIME"), ("ANY_STRING",), "(%(return_type)s)time_to_string(%(IN_value)s)"),

   368

		(("ANY_STRING",), ("ANY_DATE","TIME"), "(%(return_type)s)string_to_time(%(IN_value)s)"),

   369

		(("ANY_BIT",), ("ANY_STRING",), "(%(return_type)s)int_to_string(%(IN_value)s, 16)"),

   370

		(("ANY_NUM",), ("ANY_STRING",), "(%(return_type)s)int_to_string(%(IN_value)s, 10)"),

   371

		(("ANY_STRING",), ("ANY_BIT",), "(%(return_type)s)string_to_int(%(IN_value)s, 16)"),

   372

		(("ANY_STRING",), ("ANY_NUM",), "(%(return_type)s)string_to_int(%(IN_value)s, 10)")]

   373

   374

	for (InTypes, OutTypes, Format) in ANY_T0_ANY_LIST:

   375

		inps = reduce(lambda a,b: a or b, map(lambda testtype : IsOfType(fdecl["outputs"][0][1],testtype), InTypes))

   376

		#print "IN     ",inps , fdecl["outputs"][0][1], InTypes

   377

		outs = reduce(lambda a,b: a or b, map(lambda testtype : IsOfType(fdecl["inputs"][0][1],testtype), OutTypes))

   378

		#print "OUT    ",outs , fdecl["inputs"][0][1], OutTypes

   379

		if (inps and outs ):

   380

		 	return Format

   381

   382

	#print "IN:", fdecl["outputs"][0][1], "    OUT:", fdecl["inputs"][0][1]

   383

   384

	return "#error %s_TO_%s not implemented!"%(fdecl["inputs"][0][1],fdecl["outputs"][0][1])

   385

   386

   387

"""

   388

Returns this kind of declaration for all standard functions

   389

   390

            [{"name" : "Numerical", 'list': [   {   

   391

                'baseinputnumber': 1,

   392

                'comment': 'Addition',

   393

                'extensible': True,

   394

                'inputs': [   ('IN1', 'ANY_NUM', 'none'),

   395

                              ('IN2', 'ANY_NUM', 'none')],

   396

                'name': 'ADD',

   397

                'outputs': [('OUT', 'ANY_NUM', 'none')],

   398

                'type': 'function'}, ...... ] },.....]

   399

"""

   400

def get_standard_funtions(table):

   401

   402

	variables = get_standard_funtions_input_variables(table)

   403

   404

	fonctions = find_section("Standard_functions_type",table)

   405

   406

	Standard_Functions_Decl = []

   407

	Current_section = None

   408

	for fields in table:

   409

		if fields[1]:

   410

			# If function section name given

   411

			if fields[0] :

   412

				if Current_section: 

   413

					Standard_Functions_Decl.append(Current_section)

   414

				Current_section = { "name" : fields[0], "list" : [] }

   415

				Function_decl_list = []

   416

   417

			dico_from_table = [ (champ,val) for champ,val in zip(fonctions, fields[1:]) if champ ]

   418

			Function_decl = decl_function(dico_from_table,variables)

   419

			if Function_decl["name"].startswith('*') :

   420

				input_types = [ GetSubTypes(inpdecl[1]) for inpdecl in Function_decl["inputs"] ]

   421

				input_ovrloading_types = input_types[map(len,input_types).index(max(map(len,input_types)))]

   422

			else:

   423

				input_ovrloading_types = [None]

   424

   425

			if Function_decl["name"].endswith('*') :

   426

				output_types = GetSubTypes(Function_decl["outputs"][0][1])

   427

			else:

   428

				output_types = [None]

   429

   430

			funcdeclname_orig = Function_decl["name"]

   431

			funcdeclname = Function_decl["name"].strip('*_')

   432

			fdc = Function_decl["inputs"][:]

   433

			for intype in input_ovrloading_types:

   434

				if intype != None:

   435

					Function_decl["inputs"] = []

   436

					for decl_tpl in fdc:

   437

						if IsOfType(intype, decl_tpl[1]):

   438

							Function_decl["inputs"] += [(decl_tpl[0], intype, decl_tpl[2])]

   439

						else:

   440

							Function_decl["inputs"] += [(decl_tpl)]

   441

   442

						if funcdeclname_orig.startswith('*'):

   443

							funcdeclin = intype + '_' + funcdeclname 

   444

						else:

   445

							funcdeclin = funcdeclname

   446

				else:

   447

					funcdeclin = funcdeclname

   448

   449

   450

				if Function_decl["return_type_rule"] == "copy_input":

   451

					output_types = [intype]

   452

				elif Function_decl["return_type_rule"] == "defined":

   453

					pass

   454

   455

				for outype in output_types:

   456

					if outype != None:

   457

						decl_tpl = Function_decl["outputs"][0]

   458

						Function_decl["outputs"] = [ (decl_tpl[0] , outype,  decl_tpl[2])]

   459

						if funcdeclname_orig.endswith('*'):

   460

							funcdeclout =  funcdeclin + '_' + outype

   461

						else:

   462

							funcdeclout =  funcdeclin

   463

					else:

   464

						funcdeclout =  funcdeclin

   465

					Function_decl["name"] = funcdeclout

   466

   467

   468

					try:

   469

						fdecl = Function_decl

   470

						res = eval(Function_decl["python_eval_c_code_format"])

   471

					except Exception,e:

   472

						res = None

   473

   474

					if res != None :

   475

						# create the copy of decl dict to be appended to section

   476

						Function_decl_copy = Function_decl.copy()

   477

						# Have to generate type description in comment with freshly redefined types

   478

						Function_decl_copy["comment"] += (

   479

							"\n (" +

   480

							str([ " " + fctdecl[1]+":"+fctdecl[0] for fctdecl in Function_decl["inputs"]]).strip("[]").replace("'",'') +

   481

							" ) => (" +

   482

							str([ " " + fctdecl[1]+":"+fctdecl[0] for fctdecl in Function_decl["outputs"]]).strip("[]").replace("'",'') +

   483

							" )")

   484

						Current_section["list"].append(Function_decl_copy)

   485

						#pp.pprint(Function_decl_copy)

   486

   487

	Standard_Functions_Decl.append(Current_section)

   488

   489

	return Standard_Functions_Decl

   490

   491

   492

if __name__ == '__main__':

   493

   494

	import pprint

   495

	pp = pprint.PrettyPrinter(indent=4)

   496

   497

	def ANY_to_compiler_test_type_GEN(typename, paramname):

   498

		return {"ANY" : "",