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

import string, os, sys, re

    26

from plcopen import LoadProject

    27

from collections import OrderedDict

    28

    29

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

    30

    31

LOCATIONDATATYPES = {"X" : ["BOOL"],

    32

                     "B" : ["SINT", "USINT", "BYTE", "STRING"],

    33

                     "W" : ["INT", "UINT", "WORD", "WSTRING"],

    34

                     "D" : ["DINT", "UDINT", "REAL", "DWORD"],

    35

                     "L" : ["LINT", "ULINT", "LREAL", "LWORD"]} 

    36

    37

_ = lambda x:x

    38

    39

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

    40

#                        Function Block Types definitions

    41

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

    42

    43

ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]

    44

    45

StdBlockLibrary, error = LoadProject(

    46

    os.path.join(ScriptDirectory, "Standard_Function_Blocks.xml"))

    47

AddnlBlockLibrary, error = LoadProject(

    48

    os.path.join(ScriptDirectory, "Additional_Function_Blocks.xml"))

    49

    50

StdBlockComments = {

    51

    "SR": _("SR bistable\nThe SR bistable is a latch where the Set dominates."),

    52

    "RS": _("RS bistable\nThe RS bistable is a latch where the Reset dominates."),

    53

    "SEMA": _("Semaphore\nThe semaphore provides a mechanism to allow software elements mutually exclusive access to certain ressources."),

    54

    "R_TRIG": _("Rising edge detector\nThe output produces a single pulse when a rising edge is detected."),

    55

    "F_TRIG": _("Falling edge detector\nThe output produces a single pulse when a falling edge is detected."),

    56

    "CTU": _("Up-counter\nThe up-counter can be used to signal when a count has reached a maximum value."),

    57

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

    58

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

    59

    "TP": _("Pulse timer\nThe pulse timer can be used to generate output pulses of a given time duration."),

    60

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

    61

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

    62

    "RTC": _("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."),

    63

    "INTEGRAL": _("Integral\nThe integral function block integrates the value of input XIN over time."),

    64

    "DERIVATIVE": _("Derivative\nThe derivative function block produces an output XOUT proportional to the rate of change of the input XIN."),

    65

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

    66

    "RAMP": _("Ramp\nThe RAMP function block is modelled on example given in the standard."),

    67

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

    68

}

    69

    70

for block_type in ["CTU", "CTD", "CTUD"]:

    71

    for return_type in ["DINT", "LINT", "UDINT", "ULINT"]:

    72

        StdBlockComments["%s_%s" % (block_type, return_type)] = StdBlockComments[block_type]

    73

    74

def GetBlockInfos(pou):

    75

    infos = pou.getblockInfos()

    76

    infos["comment"] = StdBlockComments[infos["name"]]

    77

    infos["inputs"] = [

    78

        (var_name, var_type, "rising")

    79

        if var_name in ["CU", "CD"]

    80

        else (var_name, var_type, var_modifier)

    81

        for var_name, var_type, var_modifier in infos["inputs"]]

    82

    return infos

    83

    84

"""

    85

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

    86

Each block have this attributes:

    87

    - "name" : The block name

    88

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

    89

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

    90

    - "inputs" : List of the block inputs

    91

    - "outputs" : List of the block outputs

    92

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

    93

    - "generate" : Method that generator will call for generating ST block code

    94

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

    95

    - The name

    96

    - The data type

    97

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

    98

"""

    99

   100

StdBlckLst = [{"name" : _("Standard function blocks"), "list":

   101

               [GetBlockInfos(pou) for pou in StdBlockLibrary.getpous()]},

   102

              {"name" : _("Additional function blocks"), "list":

   103

               [GetBlockInfos(pou) for pou in AddnlBlockLibrary.getpous()]},

   104

             ]

   105

   106

   107

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

   108

#                           Data Types definitions

   109

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

   110

   111

"""

   112

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

   113

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

   114

between type that permits to make a comparison of two types

   115

"""

   116

TypeHierarchy_list = [

   117

    ("ANY", None),

   118

    ("ANY_DERIVED", "ANY"),

   119

    ("ANY_ELEMENTARY", "ANY"),

   120

    ("ANY_MAGNITUDE", "ANY_ELEMENTARY"),

   121

    ("ANY_BIT", "ANY_ELEMENTARY"),

   122

    ("ANY_NBIT", "ANY_BIT"),

   123

    ("ANY_STRING", "ANY_ELEMENTARY"),

   124

    ("ANY_DATE", "ANY_ELEMENTARY"),

   125

    ("ANY_NUM", "ANY_MAGNITUDE"),

   126

    ("ANY_REAL", "ANY_NUM"),

   127

    ("ANY_INT", "ANY_NUM"),

   128

    ("ANY_SINT", "ANY_INT"),

   129

    ("ANY_UINT", "ANY_INT"),

   130

    ("BOOL", "ANY_BIT"),

   131

    ("SINT", "ANY_SINT"),

   132

    ("INT", "ANY_SINT"),

   133

    ("DINT", "ANY_SINT"),

   134

    ("LINT", "ANY_SINT"),

   135

    ("USINT", "ANY_UINT"),

   136

    ("UINT", "ANY_UINT"),

   137

    ("UDINT", "ANY_UINT"),

   138

    ("ULINT", "ANY_UINT"),

   139

    ("REAL", "ANY_REAL"),

   140

    ("LREAL", "ANY_REAL"),

   141

    ("TIME", "ANY_MAGNITUDE"),

   142

    ("DATE", "ANY_DATE"),

   143

    ("TOD", "ANY_DATE"),

   144

    ("DT", "ANY_DATE"),

   145

    ("STRING", "ANY_STRING"),

   146

    ("BYTE", "ANY_NBIT"),

   147

    ("WORD", "ANY_NBIT"),

   148

    ("DWORD", "ANY_NBIT"),

   149

    ("LWORD", "ANY_NBIT")

   150

    #("WSTRING", "ANY_STRING") # TODO

   151

]

   152

   153

TypeHierarchy = dict(TypeHierarchy_list)

   154

   155

"""

   156

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

   157

"""

   158

def IsOfType(type, reference):

   159

    if reference is None:

   160

        return True

   161

    elif type == reference:

   162

        return True

   163

    else:

   164

        parent_type = TypeHierarchy[type]

   165

        if parent_type is not None:

   166

            return IsOfType(parent_type, reference)

   167

    return False

   168

   169

"""

   170

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

   171

"""

   172

def GetSubTypes(type):

   173

    return [typename for typename, parenttype in TypeHierarchy.items() if not typename.startswith("ANY") and IsOfType(typename, type)]

   174

   175

   176

DataTypeRange_list = [

   177

    ("SINT", (-2**7, 2**7 - 1)),

   178

    ("INT", (-2**15, 2**15 - 1)),

   179

    ("DINT", (-2**31, 2**31 - 1)),

   180

    ("LINT", (-2**31, 2**31 - 1)),

   181

    ("USINT", (0, 2**8 - 1)),

   182

    ("UINT", (0, 2**16 - 1)),

   183

    ("UDINT", (0, 2**31 - 1)),

   184

    ("ULINT", (0, 2**31 - 1))

   185

]

   186

   187

DataTypeRange = dict(DataTypeRange_list)

   188

   189

   190

   191

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

   192

#                             Test identifier

   193

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

   194

   195

IDENTIFIER_MODEL = re.compile(

   196

    "(?:%(letter)s|_(?:%(letter)s|%(digit)s))(?:_?(?:%(letter)s|%(digit)s))*$" %

   197

    {"letter": "[a-zA-Z]", "digit": "[0-9]"})

   198

   199

# Test if identifier is valid

   200

def TestIdentifier(identifier):

   201

     return IDENTIFIER_MODEL.match(identifier) is not None

   202

   203

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

   204

#                        Standard functions list generation

   205

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

   206

   207

   208

"""

   209

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

   210

"""            

   211

def csv_file_to_table(file):

   212

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

   213

   214

"""

   215

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

   216

return the matching row without first field

   217

"""

   218

def find_section(section_name, table):

   219

    fields = [None]

   220

    while(fields[0] != section_name):

   221

        fields = table.pop(0)

   222

    return fields[1:]

   223

   224

"""

   225

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

   226

return a { ParameterName: Type, ...}

   227

"""

   228

def get_standard_funtions_input_variables(table):

   229

    variables = find_section("Standard_functions_variables_types", table)

   230

    standard_funtions_input_variables = {}

   231

    fields = [True,True]

   232

    while(fields[1]):

   233

        fields = table.pop(0)

   234

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

   235

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

   236

    return standard_funtions_input_variables

   237

   238

"""

   239

translate .csv file input declaration into PLCOpenEditor interessting values

   240

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

   241

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

   242

"""

   243

def csv_input_translate(str_decl, variables, base):

   244

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

   245

    params = []

   246

   247

    len_of_not_predifined_variable = len([True for param_type in decl if param_type not in variables])

   248

   249

    for param_type in decl:

   250

        if param_type in variables.keys():

   251

            param_name = param_type

   252

            param_type = variables[param_type]

   253

        elif len_of_not_predifined_variable > 1:

   254

            param_name = "IN%d"%base

   255

            base += 1

   256

        else:

   257

            param_name = "IN"

   258

        params.append((param_name, param_type, "none"))

   259

    return params

   260

   261

   262

ANY_TO_ANY_LIST=[

   263

        # simple type conv are let as C cast

   264

        (("ANY_INT","ANY_BIT"),("ANY_NUM","ANY_BIT"), ("return_type", "__move_", "IN_type")),

   265

        (("ANY_REAL",),("ANY_REAL",), ("return_type", "__move_", "IN_type")),

   266

        # REAL_TO_INT

   267

        (("ANY_REAL",),("ANY_SINT",), ("return_type", "__real_to_sint", None)),

   268

        (("ANY_REAL",),("ANY_UINT",), ("return_type", "__real_to_uint", None)),

   269

        (("ANY_REAL",),("ANY_BIT",), ("return_type", "__real_to_bit", None)),

   270

        # TO_TIME

   271

        (("ANY_INT","ANY_BIT"),("ANY_DATE","TIME"), ("return_type", "__int_to_time", None)),

   272

        (("ANY_REAL",),("ANY_DATE","TIME"), ("return_type", "__real_to_time", None)),

   273

        (("ANY_STRING",), ("ANY_DATE","TIME"), ("return_type", "__string_to_time", None)),

   274

        # FROM_TIME

   275

        (("ANY_DATE","TIME"), ("ANY_REAL",), ("return_type", "__time_to_real", None)),

   276

        (("ANY_DATE","TIME"), ("ANY_INT","ANY_NBIT"), ("return_type", "__time_to_int", None)),

   277

        (("TIME",), ("ANY_STRING",), ("return_type", "__time_to_string", None)),

   278

        (("DATE",), ("ANY_STRING",), ("return_type", "__date_to_string", None)),

   279

        (("TOD",), ("ANY_STRING",), ("return_type", "__tod_to_string", None)),

   280

        (("DT",), ("ANY_STRING",), ("return_type", "__dt_to_string", None)),

   281

        # TO_STRING

   282

        (("BOOL",), ("ANY_STRING",), ("return_type", "__bool_to_string", None)),

   283

        (("ANY_BIT",), ("ANY_STRING",), ("return_type", "__bit_to_string", None)),

   284

        (("ANY_REAL",), ("ANY_STRING",), ("return_type", "__real_to_string", None)),

   285

        (("ANY_SINT",), ("ANY_STRING",), ("return_type", "__sint_to_string", None)),

   286

        (("ANY_UINT",), ("ANY_STRING",), ("return_type", "__uint_to_string", None)),

   287

        # FROM_STRING

   288

        (("ANY_STRING",), ("BOOL",), ("return_type", "__string_to_bool", None)),

   289

        (("ANY_STRING",), ("ANY_BIT",), ("return_type", "__string_to_bit", None)),

   290

        (("ANY_STRING",), ("ANY_SINT",), ("return_type", "__string_to_sint", None)),

   291

        (("ANY_STRING",), ("ANY_UINT",), ("return_type", "__string_to_uint", None)),

   292

        (("ANY_STRING",), ("ANY_REAL",), ("return_type", "__string_to_real", None))]

   293

   294

   295

BCD_TO_ANY_LIST=[

   296

        (("BYTE",),("USINT",), ("return_type", "__bcd_to_uint", None)),

   297

        (("WORD",),("UINT",), ("return_type", "__bcd_to_uint", None)),

   298

        (("DWORD",),("UDINT",), ("return_type", "__bcd_to_uint", None)),

   299

        (("LWORD",),("ULINT",), ("return_type", "__bcd_to_uint", None))]

   300

   301

   302

ANY_TO_BCD_LIST=[

   303

        (("USINT",),("BYTE",), ("return_type", "__uint_to_bcd", None)),

   304

        (("UINT",),("WORD",), ("return_type", "__uint_to_bcd", None)),

   305

        (("UDINT",),("DWORD",), ("return_type", "__uint_to_bcd", None)),

   306

        (("ULINT",),("LWORD",), ("return_type", "__uint_to_bcd", None))]

   307

   308

   309

def ANY_TO_ANY_FORMAT_GEN(any_to_any_list, fdecl):

   310

   311

    for (InTypes, OutTypes, Format) in any_to_any_list:

   312

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

   313

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

   314

        if inps and outs and fdecl["outputs"][0][1] != fdecl["inputs"][0][1]:

   315

             return Format

   316

   317

    return None

   318

   319

   320

"""

   321

Returns this kind of declaration for all standard functions

   322

   323

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

   324

                'baseinputnumber': 1,

   325

                'comment': 'Addition',

   326

                'extensible': True,

   327

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

   328

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

   329

                'name': 'ADD',

   330

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

   331

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

   332

"""

   333

def get_standard_funtions(table):

   334

   335

    variables = get_standard_funtions_input_variables(table)

   336

   337

    fonctions = find_section("Standard_functions_type",table)

   338

   339

    Standard_Functions_Decl = []

   340

    Current_section = None

   341

   342

    translate = {

   343

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

   344

            "inputs" : lambda x:csv_input_translate(x,variables,baseinputnumber),

   345

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

   346

   347

    for fields in table:

   348

        if fields[1]:

   349

            # If function section name given

   350

            if fields[0]:

   351

                words = fields[0].split('"')

   352

                if len(words) > 1:

   353

                    section_name = words[1]

   354

                else:

   355

                    section_name = fields[0]

   356

                Current_section = {"name" : section_name, "list" : []}

   357

                Standard_Functions_Decl.append(Current_section)

   358

                Function_decl_list = []

   359

            if Current_section:

   360

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

   361

                baseinputnumber = int(Function_decl.get("baseinputnumber",1))

   362

                Function_decl["baseinputnumber"] = baseinputnumber

   363

                for param, value in Function_decl.iteritems():

   364

                    if param in translate:

   365

                        Function_decl[param] = translate[param](value)

   366

                Function_decl["type"] = "function"

   367

   368

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

   369

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

   370

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

   371

                else:

   372

                    input_ovrloading_types = [None]

   373

                    output_types = [None]

   374

   375

                funcdeclname_orig = Function_decl["name"]

   376

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

   377

                fdc = Function_decl["inputs"][:]

   378

                for intype in input_ovrloading_types:

   379

                    if intype != None:

   380

                        Function_decl["inputs"] = []

   381

                        for decl_tpl in fdc:

   382

                            if IsOfType(intype, decl_tpl[1]):

   383

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

   384

                            else:

   385

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

   386

   387

                            if funcdeclname_orig.startswith('*'):

   388

                                funcdeclin = intype + '_' + funcdeclname 

   389

                            else:

   390

                                funcdeclin = funcdeclname

   391

                    else:

   392

                        funcdeclin = funcdeclname

   393

   394

                    for outype in output_types:

   395

                        if outype != None:

   396

                            decl_tpl = Function_decl["outputs"][0]

   397

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

   398

                            if funcdeclname_orig.endswith('*'):

   399

                                funcdeclout =  funcdeclin + '_' + outype

   400

                            else:

   401

                                funcdeclout =  funcdeclin

   402

                        else:

   403

                            funcdeclout =  funcdeclin

   404

                        Function_decl["name"] = funcdeclout

   405

   406

   407

                        fdecl = Function_decl

   408

                        res = eval(Function_decl["python_eval_c_code_format"])

   409

   410

                        if res != None :

   411

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

   412

                            Function_decl_copy = Function_decl.copy()

   413

                            Current_section["list"].append(Function_decl_copy)

   414

            else:

   415

                raise "First function must be in a category"

   416

   417

    return Standard_Functions_Decl

   418

   419

std_decl = get_standard_funtions(csv_file_to_table(open(os.path.join(ScriptDirectory,"iec_std.csv"))))#, True)

   420

   421

StdBlckLst.extend(std_decl)

   422

   423

# Dictionary to speedup block type fetching by name

   424

StdBlckDct = OrderedDict()

   425

   426

for section in StdBlckLst:

   427

    for desc in section["list"]:

   428

        words = desc["comment"].split('"')

   429

        if len(words) > 1:

   430

            desc["comment"] = words[1]

   431

        desc["usage"] = ("\n (%s) => (%s)" % 

   432

            (", ".join(["%s:%s" % (input[1], input[0]) 

   433

                        for input in desc["inputs"]]),

   434

             ", ".join(["%s:%s" % (output[1], output[0]) 

   435

                        for output in desc["outputs"]])))

   436

        BlkLst = StdBlckDct.setdefault(desc["name"],[])

   437

        BlkLst.append((section["name"], desc))

   438

   439

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

   440

#                            Languages Keywords

   441

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

   442

   443

   444

# Keywords for Pou Declaration

   445

POU_BLOCK_START_KEYWORDS = ["FUNCTION", "FUNCTION_BLOCK", "PROGRAM"]

   446

POU_BLOCK_END_KEYWORDS = ["END_FUNCTION", "END_FUNCTION_BLOCK", "END_PROGRAM"]

   447

POU_KEYWORDS = ["EN", "ENO", "F_EDGE", "R_EDGE"] + POU_BLOCK_START_KEYWORDS + POU_BLOCK_END_KEYWORDS

   448

for category in StdBlckLst:

   449

    for block in category["list"]:

   450

        if block["name"] not in POU_KEYWORDS:

   451

            POU_KEYWORDS.append(block["name"])

   452

   453

   454

# Keywords for Type Declaration

   455

TYPE_BLOCK_START_KEYWORDS = ["TYPE", "STRUCT"]

   456

TYPE_BLOCK_END_KEYWORDS = ["END_TYPE", "END_STRUCT"]

   457

TYPE_KEYWORDS = ["ARRAY", "OF", "T", "D", "TIME_OF_DAY", "DATE_AND_TIME"] + TYPE_BLOCK_START_KEYWORDS + TYPE_BLOCK_END_KEYWORDS

   458

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

   459

   460

   461

# Keywords for Variable Declaration

   462

VAR_BLOCK_START_KEYWORDS = ["VAR", "VAR_INPUT", "VAR_OUTPUT", "VAR_IN_OUT", "VAR_TEMP", "VAR_EXTERNAL"]

   463

VAR_BLOCK_END_KEYWORDS = ["END_VAR"]

   464

VAR_KEYWORDS = ["AT", "CONSTANT", "RETAIN", "NON_RETAIN"] + VAR_BLOCK_START_KEYWORDS + VAR_BLOCK_END_KEYWORDS

   465

   466

   467

# Keywords for Configuration Declaration

   468

CONFIG_BLOCK_START_KEYWORDS = ["CONFIGURATION", "RESOURCE", "VAR_ACCESS", "VAR_CONFIG", "VAR_GLOBAL"]

   469

CONFIG_BLOCK_END_KEYWORDS = ["END_CONFIGURATION", "END_RESOURCE", "END_VAR"]

   470

CONFIG_KEYWORDS = ["ON", "PROGRAM", "WITH", "READ_ONLY", "READ_WRITE", "TASK"] + CONFIG_BLOCK_START_KEYWORDS + CONFIG_BLOCK_END_KEYWORDS

   471

   472

# Keywords for Structured Function Chart

   473

SFC_BLOCK_START_KEYWORDS = ["ACTION", "INITIAL_STEP", "STEP", "TRANSITION"]

   474

SFC_BLOCK_END_KEYWORDS = ["END_ACTION", "END_STEP", "END_TRANSITION"]

   475

SFC_KEYWORDS = ["FROM", "TO"] + SFC_BLOCK_START_KEYWORDS + SFC_BLOCK_END_KEYWORDS

   476

   477

   478

# Keywords for Instruction List

   479

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

   480

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

   481

 "LE", "LT", "JMP", "JMPC", "JMPCN", "CAL", "CALC", "CALCN", "RET", "RETC", "RETCN"]

   482

   483

   484

# Keywords for Structured Text

   485

ST_BLOCK_START_KEYWORDS = ["IF", "ELSIF", "ELSE", "CASE", "FOR", "WHILE", "REPEAT"]

   486

ST_BLOCK_END_KEYWORDS = ["END_IF", "END_CASE", "END_FOR", "END_WHILE", "END_REPEAT"]

   487

ST_KEYWORDS = ["TRUE", "FALSE", "THEN", "OF", "TO", "BY", "DO", "DO", "UNTIL", "EXIT", 

   488

 "RETURN", "NOT", "MOD", "AND", "XOR", "OR"] + ST_BLOCK_START_KEYWORDS + ST_BLOCK_END_KEYWORDS

   489

   490

# All the keywords of IEC

   491

IEC_BLOCK_START_KEYWORDS = []

   492

IEC_BLOCK_END_KEYWORDS = []

   493

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

   494

for all_keywords, keywords_list in [(IEC_BLOCK_START_KEYWORDS, [POU_BLOCK_START_KEYWORDS, TYPE_BLOCK_START_KEYWORDS,

   495

                                                                VAR_BLOCK_START_KEYWORDS, CONFIG_BLOCK_START_KEYWORDS,

   496

                                                                SFC_BLOCK_START_KEYWORDS, ST_BLOCK_START_KEYWORDS]),

   497

                                    (IEC_BLOCK_END_KEYWORDS, [POU_BLOCK_END_KEYWORDS, TYPE_BLOCK_END_KEYWORDS,

   498

                                                              VAR_BLOCK_END_KEYWORDS, CONFIG_BLOCK_END_KEYWORDS,

   499

                                                              SFC_BLOCK_END_KEYWORDS, ST_BLOCK_END_KEYWORDS]),

   500

                                    (IEC_KEYWORDS, [POU_KEYWORDS, TYPE_KEYWORDS, VAR_KEYWORDS, CONFIG_KEYWORDS,

   501

                                                    SFC_KEYWORDS, IL_KEYWORDS, ST_KEYWORDS])]:

   502

    for keywords in keywords_list:

   503

        all_keywords.extend([keyword for keyword in keywords if keyword not in all_keywords])

   504