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

    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 = LoadProject(os.path.join(ScriptDirectory, "Standard_Function_Blocks.xml"))

    46

AddnlBlockLibrary = LoadProject(os.path.join(ScriptDirectory, "Additional_Function_Blocks.xml"))

    47

    48

StdBlockComments = {

    49

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

    50

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

    51

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

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

}

    67

    68

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

    69

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

    70

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

    71

    72

def GetBlockInfos(pou):

    73

    infos = pou.getblockInfos()

    74

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

    75

    infos["inputs"] = [

    76

        (var_name, var_type, "rising")

    77

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

    78

        else (var_name, var_type, var_modifier)

    79

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

    80

    return infos

    81

    82

"""

    83

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

    84

Each block have this attributes:

    85

    - "name" : The block name

    86

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

    87

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

    88

    - "inputs" : List of the block inputs

    89

    - "outputs" : List of the block outputs

    90

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

    91

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

    92

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

    93

    - The name

    94

    - The data type

    95

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

    96

"""

    97

    98

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

    99

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

   100

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

   101

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

   102

             ]

   103

   104

   105

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

   106

#                           Data Types definitions

   107

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

   108

   109

"""

   110

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

   111

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

   112

between type that permits to make a comparison of two types

   113

"""

   114

TypeHierarchy_list = [

   115

    ("ANY", None),

   116

    ("ANY_DERIVED", "ANY"),

   117

    ("ANY_ELEMENTARY", "ANY"),

   118

    ("ANY_MAGNITUDE", "ANY_ELEMENTARY"),

   119

    ("ANY_BIT", "ANY_ELEMENTARY"),

   120

    ("ANY_NBIT", "ANY_BIT"),

   121

    ("ANY_STRING", "ANY_ELEMENTARY"),

   122

    ("ANY_DATE", "ANY_ELEMENTARY"),

   123

    ("ANY_NUM", "ANY_MAGNITUDE"),

   124

    ("ANY_REAL", "ANY_NUM"),

   125

    ("ANY_INT", "ANY_NUM"),

   126

    ("ANY_SINT", "ANY_INT"),

   127

    ("ANY_UINT", "ANY_INT"),

   128

    ("BOOL", "ANY_BIT"),

   129

    ("SINT", "ANY_SINT"),

   130

    ("INT", "ANY_SINT"),

   131

    ("DINT", "ANY_SINT"),

   132

    ("LINT", "ANY_SINT"),

   133

    ("USINT", "ANY_UINT"),

   134

    ("UINT", "ANY_UINT"),

   135

    ("UDINT", "ANY_UINT"),

   136

    ("ULINT", "ANY_UINT"),

   137

    ("REAL", "ANY_REAL"),

   138

    ("LREAL", "ANY_REAL"),

   139

    ("TIME", "ANY_MAGNITUDE"),

   140

    ("DATE", "ANY_DATE"),

   141

    ("TOD", "ANY_DATE"),

   142

    ("DT", "ANY_DATE"),

   143

    ("STRING", "ANY_STRING"),

   144

    ("BYTE", "ANY_NBIT"),

   145

    ("WORD", "ANY_NBIT"),

   146

    ("DWORD", "ANY_NBIT"),

   147

    ("LWORD", "ANY_NBIT")

   148

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

   149

]

   150

   151

TypeHierarchy = dict(TypeHierarchy_list)

   152

   153

"""

   154

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

   155

"""

   156

def IsOfType(type, reference):

   157

    if reference is None:

   158

        return True

   159

    elif type == reference:

   160

        return True

   161

    else:

   162

        parent_type = TypeHierarchy[type]

   163

        if parent_type is not None:

   164

            return IsOfType(parent_type, reference)

   165

    return False

   166

   167

"""

   168

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

   169

"""

   170

def GetSubTypes(type):

   171

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

   172

   173

   174

DataTypeRange_list = [

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

]

   184

   185

DataTypeRange = dict(DataTypeRange_list)

   186

   187

   188

   189

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

   190

#                             Test identifier

   191

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

   192

   193

IDENTIFIER_MODEL = re.compile(

   194

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

   195

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

   196

   197

# Test if identifier is valid

   198

def TestIdentifier(identifier):

   199

     return IDENTIFIER_MODEL.match(identifier) is not None

   200

   201

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

   202

#                        Standard functions list generation

   203

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

   204

   205

   206

"""

   207

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

   208

"""            

   209

def csv_file_to_table(file):

   210

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

   211

   212

"""

   213

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

   214

return the matching row without first field

   215

"""

   216

def find_section(section_name, table):

   217

    fields = [None]

   218

    while(fields[0] != section_name):

   219

        fields = table.pop(0)

   220

    return fields[1:]

   221

   222

"""

   223

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

   224

return a { ParameterName: Type, ...}

   225

"""

   226

def get_standard_funtions_input_variables(table):

   227

    variables = find_section("Standard_functions_variables_types", table)

   228

    standard_funtions_input_variables = {}

   229

    fields = [True,True]

   230

    while(fields[1]):

   231

        fields = table.pop(0)

   232

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

   233

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

   234

    return standard_funtions_input_variables

   235

   236

"""

   237

translate .csv file input declaration into PLCOpenEditor interessting values

   238

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

   239

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

   240

"""

   241

def csv_input_translate(str_decl, variables, base):

   242

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

   243

    params = []

   244

   245

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

   246

   247

    for param_type in decl:

   248

        if param_type in variables.keys():

   249

            param_name = param_type

   250

            param_type = variables[param_type]

   251

        elif len_of_not_predifined_variable > 1:

   252

            param_name = "IN%d"%base

   253

            base += 1

   254

        else:

   255

            param_name = "IN"

   256

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

   257

    return params

   258

   259

   260

ANY_TO_ANY_LIST=[

   261

        # simple type conv are let as C cast

   262

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

   263

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

   264

        # REAL_TO_INT

   265

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

   266

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

   267

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

   268

        # TO_TIME

   269

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

   270

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

   271

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

   272

        # FROM_TIME

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

        # TO_STRING

   280

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

   281

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

   282

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

   283

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

   284

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

   285

        # FROM_STRING

   286

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

   287

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

   288

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

   289

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

   290

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

   291

   292

   293

BCD_TO_ANY_LIST=[

   294

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

   295

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

   296

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

   297

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

   298

   299

   300

ANY_TO_BCD_LIST=[

   301

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

   302

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

   303

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

   304

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

   305

   306

   307

def ANY_TO_ANY_FORMAT_GEN(any_to_any_list, fdecl):

   308

   309

    for (InTypes, OutTypes, Format) in any_to_any_list:

   310

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

   311

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

   312

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

   313

             return Format

   314

   315

    return None

   316

   317

   318

"""

   319

Returns this kind of declaration for all standard functions

   320

   321

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

   322

                'baseinputnumber': 1,

   323

                'comment': 'Addition',

   324

                'extensible': True,

   325

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

   326

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

   327

                'name': 'ADD',

   328

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

   329

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

   330

"""

   331

def get_standard_funtions(table):

   332

   333

    variables = get_standard_funtions_input_variables(table)

   334

   335

    fonctions = find_section("Standard_functions_type",table)

   336

   337

    Standard_Functions_Decl = []

   338

    Current_section = None

   339

   340

    translate = {

   341

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

   342

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

   343

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

   344

   345

    for fields in table:

   346

        if fields[1]:

   347

            # If function section name given

   348

            if fields[0]:

   349

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

   350

                if len(words) > 1:

   351

                    section_name = words[1]

   352

                else:

   353

                    section_name = fields[0]

   354

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

   355

                Standard_Functions_Decl.append(Current_section)

   356

                Function_decl_list = []

   357

            if Current_section:

   358

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

   359

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

   360

                Function_decl["baseinputnumber"] = baseinputnumber

   361

                for param, value in Function_decl.iteritems():

   362

                    if param in translate:

   363

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

   364

                Function_decl["type"] = "function"

   365

   366

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

   367

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

   368

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

   369

                else:

   370

                    input_ovrloading_types = [None]

   371

                    output_types = [None]

   372

   373

                funcdeclname_orig = Function_decl["name"]

   374

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

   375

                fdc = Function_decl["inputs"][:]

   376

                for intype in input_ovrloading_types:

   377

                    if intype != None:

   378

                        Function_decl["inputs"] = []

   379

                        for decl_tpl in fdc:

   380

                            if IsOfType(intype, decl_tpl[1]):

   381

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

   382

                            else:

   383

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

   384

   385

                            if funcdeclname_orig.startswith('*'):

   386

                                funcdeclin = intype + '_' + funcdeclname 

   387

                            else:

   388

                                funcdeclin = funcdeclname

   389

                    else:

   390

                        funcdeclin = funcdeclname

   391

   392

                    for outype in output_types:

   393

                        if outype != None:

   394

                            decl_tpl = Function_decl["outputs"][0]

   395

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

   396

                            if funcdeclname_orig.endswith('*'):

   397

                                funcdeclout =  funcdeclin + '_' + outype

   398

                            else:

   399

                                funcdeclout =  funcdeclin

   400

                        else:

   401

                            funcdeclout =  funcdeclin

   402

                        Function_decl["name"] = funcdeclout

   403

   404

   405

                        fdecl = Function_decl

   406

                        res = eval(Function_decl["python_eval_c_code_format"])

   407

   408

                        if res != None :

   409

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

   410

                            Function_decl_copy = Function_decl.copy()

   411

                            Current_section["list"].append(Function_decl_copy)

   412

            else:

   413

                raise "First function must be in a category"

   414

   415

    return Standard_Functions_Decl

   416

   417

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

   418

   419

StdBlckLst.extend(std_decl)

   420

   421

# Dictionary to speedup block type fetching by name

   423

   424

for section in StdBlckLst:

   425

    for desc in section["list"]:

   426

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

   427

        if len(words) > 1:

   428

            desc["comment"] = words[1]

   429

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

   430

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

   431

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

   432

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

   433

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

   434

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

   435

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

   436

   437

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

   438

#                            Languages Keywords

   439

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

   440

   441

   442

# Keywords for Pou Declaration

   443

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

   444

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

   445

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

   446

for category in StdBlckLst:

   447

    for block in category["list"]:

   448

        if block["name"] not in POU_KEYWORDS:

   449

            POU_KEYWORDS.append(block["name"])

   450

   451

   452

# Keywords for Type Declaration

   453

TYPE_BLOCK_START_KEYWORDS = ["TYPE", "STRUCT"]

   454

TYPE_BLOCK_END_KEYWORDS = ["END_TYPE", "END_STRUCT"]

   455

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

   456

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

   457

   458

   459

# Keywords for Variable Declaration

   460

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

   461

VAR_BLOCK_END_KEYWORDS = ["END_VAR"]

   462

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

   463

   464

   465

# Keywords for Configuration Declaration

   466

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

   467

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

   468

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

   469

   470

# Keywords for Structured Function Chart

   471

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

   472

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

   473

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

   474

   475

   476

# Keywords for Instruction List

   477

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

   478

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

   479

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

   480

   481

   482

# Keywords for Structured Text

   483

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

   484

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

   485

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

   486

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

   487

   488

# All the keywords of IEC

   489

IEC_BLOCK_START_KEYWORDS = []

   490

IEC_BLOCK_END_KEYWORDS = []

   491

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

   492

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

   493

                                                                VAR_BLOCK_START_KEYWORDS, CONFIG_BLOCK_START_KEYWORDS,

   494

                                                                SFC_BLOCK_START_KEYWORDS, ST_BLOCK_START_KEYWORDS]),

   495

                                    (IEC_BLOCK_END_KEYWORDS, [POU_BLOCK_END_KEYWORDS, TYPE_BLOCK_END_KEYWORDS,

   496

                                                              VAR_BLOCK_END_KEYWORDS, CONFIG_BLOCK_END_KEYWORDS,

   497

                                                              SFC_BLOCK_END_KEYWORDS, ST_BLOCK_END_KEYWORDS]),

   498

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

   499

                                                    SFC_KEYWORDS, IL_KEYWORDS, ST_KEYWORDS])]:

   500

    for keywords in keywords_list:

   501

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

   502