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

    30

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

    31

#                        Function Block Types definitions

    32

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

    33

    34

"""

    35

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

    36

Each block have this attributes:

    37

    - "name" : The block name

    38

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

    39

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

    40

    - "inputs" : List of the block inputs

    41

    - "outputs" : List of the block outputs

    42

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

    43

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

    44

    - The name

    45

    - The data type

    46

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

    47

"""

    48

    49

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

    50

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

    51

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

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

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

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

                    "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."},

    82

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

    83

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

    84

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

    85

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

    86

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

    87

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

    88

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

    89

                    "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."},

    90

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

    91

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

    92

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

    93

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

    94

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

    95

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

    96

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

    97

                    "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."},

    98

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

    99

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

   100

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

   101

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

   102

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

   103

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

   104

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

   105

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

   106

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

   107

                    "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")], 

   108

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

   109

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

   110

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

   111

                    "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")], 

   112

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

   113

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

   114

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

   115

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

   116

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

   117

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

   118

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

   119

                    "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")], 

   120

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

   121

                    "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."},

   122

               ]}

   123

             ]

   124

   125

"""

   126

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

   127

"""

   128

   129

def GetBlockType(type):

   130

    for category in BlockTypes:

   131

        for blocktype in category["list"]:

   132

            if blocktype["name"] == type:

   133

                return blocktype

   134

    return None

   135

   136

   137

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

   138

#                           Data Types definitions

   139

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

   140

   141

"""

   142

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

   143

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

   144

between type that permits to make a comparison of two types

   145

"""

   146

   147

TypeHierarchy = {"ANY" : None,

   148

                 "ANY_DERIVED" : "ANY",

   149

                 "ANY_ELEMENTARY" : "ANY",

   150

                 "ANY_MAGNITUDE": "ANY_ELEMENTARY",

   151

                 "ANY_BIT" : "ANY_ELEMENTARY",

   152

                 "ANY_STRING" : "ANY_ELEMENTARY",

   153

                 "ANY_DATE" : "ANY_ELEMENTARY",

   154

                 "ANY_NUM" : "ANY_MAGNITUDE",

   155

                 "ANY_REAL" : "ANY_NUM",

   156

                 "ANY_INT" : "ANY_NUM",

   157

                 "REAL" : "ANY_REAL",

   158

                 "LREAL" : "ANY_REAL",

   159

                 "SINT" : "ANY_INT",

   160

                 "INT" : "ANY_INT",

   161

                 "DINT" : "ANY_INT",

   162

                 "LINT" : "ANY_INT",

   163

                 "USINT" : "ANY_INT",

   164

                 "UINT" : "ANY_INT",

   165

                 "UDINT" : "ANY_INT",

   166

                 "ULINT" : "ANY_INT",

   167

                 "TIME" : "ANY_MAGNITUDE",

   168

                 "BOOL" : "ANY_BIT",

   169

                 "BYTE" : "ANY_BIT",

   170

                 "WORD" : "ANY_BIT",

   171

                 "DWORD" : "ANY_BIT",

   172

                 "LWORD" : "ANY_BIT",

   173

                 "STRING" : "ANY_STRING",

   174

                 "WSTRING" : "ANY_STRING",

   175

                 "DATE" : "ANY_DATE",

   176

                 "TOD" : "ANY_DATE",

   177

                 "DT" : "ANY_DATE"

   178

}

   179

   180

"""

   181

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

   182

"""

   183

   184

def IsOfType(test, reference):

   185

    while test != None:

   186

        if test == reference:

   187

            return True

   188

        test = TypeHierarchy[test]

   189

    return False

   190

   191

"""

   192

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

   193

"""

   194

def GetSubTypes(reference):

   195

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

   196

   197

"""

   198

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

   199

"""            

   200

def csv_file_to_table(file):

   201

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

   202

   203

"""

   204

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

   205

return the matching row without first field

   206

"""

   207

def find_section(section_name, table):

   208

	fields = [None]

   209

	while(fields[0] != section_name):

   210

		fields = table.pop(0)

   211

	return fields[1:]

   212

   213

"""

   214

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

   215

return a { ParameterName: Type, ...}

   216

"""

   217

def get_standard_funtions_input_variables(table):

   218

	variables = find_section("Standard_functions_variables_types", table)

   219

	standard_funtions_input_variables = {}

   220

	fields = [True,True]

   221

	while(fields[1]):

   222

		fields = table.pop(0)

   223

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

   224

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

   225

	return standard_funtions_input_variables

   226

   227

"""

   228

translate .csv file input declaration into PLCOpenEditor interessting values

   229

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

   230

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

   231

"""

   232

def csv_input_translate(str_decl, variables, base):

   233

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

   234

	param_types = []

   235

	param_names = []

   236

	modifiers = []

   237

	if len(decl)>1 : suffix = str(base)

   238

	else: suffix = ''

   239

   240

	for param_type in decl:

   241

		predifined_variable_param_type = variables.get(param_type,None)

   242

		if predifined_variable_param_type :

   243

			param_types.append(predifined_variable_param_type)

   244

			param_names.append(param_type)

   245

		else:

   246

			param_types.append(param_type)

   247

			param_names.append("IN"+suffix)

   248

			base+=1

   249

			suffix = str(base)

   250

   251

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

   252

	return zip(param_names,param_types,modifiers)

   253

   254

"""

   255

Fillin the PLCOpenEditor standard function dictionnary

   256

translate input and output declaration to something more pythonesque

   257

and add interface description to comment

   258

"""

   259

def decl_function(dico_from_table, variables):

   260

	Function_decl = { "type" : "function" }

   261

	for field, val in dico_from_table:

   262

		translate = {

   263

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

   264

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

   265

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

   266

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

   267

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

   268

	#Function_decl.pop("baseinputnumber")

   269

	Function_decl.pop("overloaded")

   270

	return Function_decl

   271

   272

"""

   273

Returns this kind of declaration for all standard functions

   274

   275

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

   276

                'baseinputnumber': 1,

   277

                'comment': 'Addition',

   278

                'extensible': True,

   279

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

   280

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

   281

                'name': 'ADD',

   282

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

   283

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

   284

"""

   285

def get_standard_funtions(table):

   286

   287

	variables = get_standard_funtions_input_variables(table)

   288

   289

	fonctions = find_section("Standard_functions_type",table)

   290

   291

	Standard_Functions_Decl = []

   292

	Current_section = None

   293

	for fields in table:

   294

		if fields[1]:

   295

			# If function section name given

   296

			if fields[0] :

   297

				if Current_section: 

   298

					Standard_Functions_Decl.append(Current_section)

   299

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

   300

				Function_decl_list = []

   301

   302

			dico_from_table = zip(fonctions, fields[1:])

   303

			Function_decl = decl_function(dico_from_table,variables)

   304

   305

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

   306

				input_types = GetSubTypes(Function_decl["inputs"][0][1])

   307

			else:

   308

				input_types = [None]

   309

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

   310

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

   311

			else:

   312

				output_types = [None]

   313

   314

			funcdecl = Function_decl["name"]

   315

			for intype in input_types:

   316

				if intype != None:

   317

					decl_tpl = Function_decl["inputs"][0]

   318

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

   319

					funcdeclin = funcdecl.replace("*_", intype + '_')

   320

					Function_decl["name"] = funcdeclin

   321

   322

				for outype in output_types:

   323

					if outype != None:

   324

						decl_tpl = Function_decl["outputs"][0]

   325

						Function_decl["outputs"] = [decl_tpl[:1] + (outype,) + decl_tpl[2:]] + Function_decl["outputs"][1:]

   326

						funcdeclout = funcdeclin.replace("_**", '_' + outype)

   327

						Function_decl["name"] = funcdeclout

   328

   329

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

   330

					Function_decl_copy = Function_decl.copy()

   331

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

   332

					Function_decl_copy["comment"] += ("\n (" +

   333

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

   334

						" ) => (" +

   335

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

   336

						" )")

   337

					Current_section["list"].append(Function_decl_copy)

   338

   339

	return Standard_Functions_Decl

   340

   341

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

   342

#                             Test identifier

   343

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

   344

   345

   346

   347

# Test if identifier is valid

   348

def TestIdentifier(identifier):

   349

     if identifier[0].isdigit():

   350

        return False

   351

     words = identifier.split('_')

   352

     for i, word in enumerate(words):

   353

         if len(word) == 0 and i != 0:

   354

             return False

   355

         if len(word) != 0 and not word.isalnum():

   356

             return False

   357

     return True

   358

   359

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

   360

#                            Languages Keywords

   361

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

   362

   363

   364

   365

# Keywords for Pou Declaration

   366

POU_KEYWORDS = ["FUNCTION", "END_FUNCTION", "FUNCTION_BLOCK", "END_FUNCTION_BLOCK",

   367

 "PROGRAM", "END_PROGRAM", "EN", "ENO", "F_EDGE", "R_EDGE"]

   368

for category in BlockTypes:

   369

    for block in category["list"]:

   370

        if block["name"] not in POU_KEYWORDS:

   371

            POU_KEYWORDS.append(block["name"])

   372

   373

   374

# Keywords for Type Declaration

   375

TYPE_KEYWORDS = ["TYPE", "END_TYPE", "STRUCT", "END_STRUCT", "ARRAY", "OF", "T",

   376

 "D", "TIME_OF_DAY", "DATE_AND_TIME"]

   377

TYPE_KEYWORDS.extend([keyword for keyword in TypeHierarchy.keys() if keyword not in TYPE_KEYWORDS])

   378

   379

   380

# Keywords for Variable Declaration

   381

VAR_KEYWORDS = ["VAR", "VAR_INPUT", "VAR_OUTPUT", "VAR_IN_OUT", "VAR_TEMP", 

   382

 "VAR_EXTERNAL", "END_VAR", "AT", "CONSTANT", "RETAIN", "NON_RETAIN"]

   383

   384

   385

# Keywords for Configuration Declaration

   386

CONFIG_KEYWORDS = ["CONFIGURATION", "END_CONFIGURATION", "RESOURCE", "ON", "END_RESOURCE",

   387

 "PROGRAM", "WITH", "READ_ONLY", "READ_WRITE", "TASK", "VAR_ACCESS", "VAR_CONFIG", 

   388

 "VAR_GLOBAL", "END_VAR"]

   389

   390

   391

# Keywords for Structured Function Chart

   392

SFC_KEYWORDS = ["ACTION", "END_ACTION", "INITIAL_STEP", "STEP", "END_STEP", "TRANSITION",

   393

 "FROM", "TO", "END_TRANSITION"]

   394

   395

   396

# Keywords for Instruction List

   397

IL_KEYWORDS = ["LD", "LDN", "ST", "STN", "S", "R", "AND", "ANDN", "OR", "ORN",

   398

 "XOR", "XORN", "NOT", "ADD", "SUB", "MUL", "DIV", "MOD", "GT", "GE", "EQ", "NE",

   399

 "LE", "LT", "JMP", "JMPC", "JMPNC", "CAL", "CALC", "CALNC", "RET", "RETC", "RETNC"]

   400

   401

   402

# Keywords for Instruction List and Structured Text

   403

ST_KEYWORDS = ["IF", "THEN", "ELSIF", "ELSE", "END_IF", "CASE", "OF", "END_CASE", 

   404

 "FOR", "TO", "BY", "DO", "END_FOR", "WHILE", "DO", "END_WHILE", "REPEAT", "UNTIL", 

   405

 "END_REPEAT", "EXIT", "RETURN", "NOT", "MOD", "AND", "XOR", "OR"]

   406

   407

   408

# All the keywords of IEC

   409

IEC_KEYWORDS = ["E", "TRUE", "FALSE"]

   410

IEC_KEYWORDS.extend([keyword for keyword in POU_KEYWORDS if keyword not in IEC_KEYWORDS])

   411

IEC_KEYWORDS.extend([keyword for keyword in TYPE_KEYWORDS if keyword not in IEC_KEYWORDS])

   412

IEC_KEYWORDS.extend([keyword for keyword in VAR_KEYWORDS if keyword not in IEC_KEYWORDS])

   413

IEC_KEYWORDS.extend([keyword for keyword in CONFIG_KEYWORDS if keyword not in IEC_KEYWORDS])

   414

IEC_KEYWORDS.extend([keyword for keyword in SFC_KEYWORDS if keyword not in IEC_KEYWORDS])

   415

IEC_KEYWORDS.extend([keyword for keyword in IL_KEYWORDS if keyword not in IEC_KEYWORDS])

   416

IEC_KEYWORDS.extend([keyword for keyword in ST_KEYWORDS if keyword not in IEC_KEYWORDS])

   417

   418

if __name__ == '__main__':

   419

	import pprint

   420

	pp = pprint.PrettyPrinter(indent=4)

   421

	std_decl = get_standard_funtions(csv_file_to_table(open("iec_std.csv")))

   422

	pp.pprint(std_decl)

   423

else:

   424

	# Put standard functions declaration in Bloktypes

   425

	BlockTypes.extend(get_standard_funtions(csv_file_to_table(open(os.path.join(sys.path[0], "plcopen/iec_std.csv")))))

   426