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

"""

   180

   181

"""

   182

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

   183

"""

   184

   185

def IsOfType(test, reference):

   186

    while test != None:

   187

        if test == reference:

   188

            return True

   189

        test = TypeHierarchy[test]

   190

    return False

   191

   192

"""

   193

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

   194

"""

   195

def GetSubTypes(reference):

   196

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

   197

   203

"""

   204

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

   205

"""            

   206

def csv_file_to_table(file):

   207

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

   208

   209

"""

   210

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

   211

return the matching row without first field

   212

"""

   213

def find_section(section_name, table):

   214

	fields = [None]

   215

	while(fields[0] != section_name):

   216

		fields = table.pop(0)

   217

	return fields[1:]

   218

   219

"""

   220

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

   221

return a { ParameterName: Type, ...}

   222

"""

   223

def get_standard_funtions_input_variables(table):

   224

	variables = find_section("Standard_functions_variables_types", table)

   225

	standard_funtions_input_variables = {}

   226

	fields = [True,True]

   227

	while(fields[1]):

   228

		fields = table.pop(0)

   230

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

   231

	return standard_funtions_input_variables

   232

   233

"""

   234

translate .csv file input declaration into PLCOpenEditor interessting values

   235

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

   236

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

   237

"""

   238

def csv_input_translate(str_decl, variables, base):

   239

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

   240

	param_types = []

   241

	param_names = []

   242

	modifiers = []

   251

	else: suffix = ''

   252

   253

	for param_type in decl:

   254

		predifined_variable_param_type = variables.get(param_type,None)

   255

		if predifined_variable_param_type :

   256

			param_types.append(predifined_variable_param_type)

   257

			param_names.append(param_type)

   258

		else:

   259

			param_types.append(param_type)

   260

			param_names.append("IN"+suffix)

   261

			base+=1

   262

			suffix = str(base)

   263

   264

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

   265

	return zip(param_names,param_types,modifiers)

   266

   267

"""

   268

Fillin the PLCOpenEditor standard function dictionnary

   269

translate input and output declaration to something more pythonesque

   270

and add interface description to comment

   271

"""

   272

def decl_function(dico_from_table, variables):

   273

	Function_decl = { "type" : "function" }

   274

	for field, val in dico_from_table:

   275

		translate = {

   276

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

   277

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

   278

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

   279

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

   280

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

   281

	return Function_decl

   282

   310

"""

   311

Returns this kind of declaration for all standard functions

   312

   313

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

   314

                'baseinputnumber': 1,

   315

                'comment': 'Addition',

   316

                'extensible': True,

   317

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

   318

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

   319

                'name': 'ADD',

   320

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

   321

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

   322

"""

   323

def get_standard_funtions(table):

   324

   325

	variables = get_standard_funtions_input_variables(table)

   326

   327

	fonctions = find_section("Standard_functions_type",table)

   328

   329

	Standard_Functions_Decl = []

   330

	Current_section = None

   331

	for fields in table:

   332

		if fields[1]:

   333

			# If function section name given

   334

			if fields[0] :

   335

				if Current_section: 

   336

					Standard_Functions_Decl.append(Current_section)

   337

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

   338

				Function_decl_list = []

   339

   341

			Function_decl = decl_function(dico_from_table,variables)

   345

			else:

   349

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

   350

			else:

   351

				output_types = [None]

   352

   357

				if intype != None:

   377

   378

				for outype in output_types:

   379

					if outype != None:

   380

						decl_tpl = Function_decl["outputs"][0]

   411

   412

	return Standard_Functions_Decl

   413

   414

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

   415

#                             Test identifier

   416

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

   417

   418

   419

   420

# Test if identifier is valid

   421

def TestIdentifier(identifier):

   422

     if identifier[0].isdigit():

   423

        return False

   424

     words = identifier.split('_')

   425

     for i, word in enumerate(words):

   426

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

   427

             return False

   428

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

   429

             return False

   430

     return True

   431

   432

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

   433

#                            Languages Keywords

   434

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

   435

   436

   437

   438

# Keywords for Pou Declaration

   439

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

   440

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

   441

for category in BlockTypes:

   442

    for block in category["list"]:

   443

        if block["name"] not in POU_KEYWORDS:

   444

            POU_KEYWORDS.append(block["name"])

   445

   446

   447

# Keywords for Type Declaration

   448

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

   449

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

   450

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

   451

   452

   453

# Keywords for Variable Declaration

   454

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

   455

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

   456

   457

   458

# Keywords for Configuration Declaration

   459

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

   460

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

   461

 "VAR_GLOBAL", "END_VAR"]

   462

   463

   464

# Keywords for Structured Function Chart

   465

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

   466

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

   467

   468

   469

# Keywords for Instruction List

   470

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

   471

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

   472

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

   473

   474

   475

# Keywords for Instruction List and Structured Text

   476

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

   477

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

   478

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

   479

   480

   481

# All the keywords of IEC

   482

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

   483

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

   484

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

   485

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

   486

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

   487

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

   488

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

   489

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

   490

   491

if __name__ == '__main__':

   493

	import pprint

   494

	pp = pprint.PrettyPrinter(indent=4)