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

"""

   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

   194

def GetSubTypes(reference):

   195

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

   196

   200

def csv_file_to_table(file):

   201

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

   202

   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

   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

   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

   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

   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

   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