1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

    26

    27

import re

    28

from collections import OrderedDict

    29

from functools import reduce

    30

    31

from . plcopen import LoadProject

    32

from . definitions import *

    33

    34

TypeHierarchy = dict(TypeHierarchy_list)

    35

    36

    37

def IsOfType(type, reference):

    38

    """

    39

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

    40

    """

    41

    if reference is None:

    42

        return True

    43

    elif type == reference:

    44

        return True

    45

    else:

    46

        parent_type = TypeHierarchy[type]

    47

        if parent_type is not None:

    48

            return IsOfType(parent_type, reference)

    49

    return False

    50

    51

    52

def GetSubTypes(type):

    53

    """

    54

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

    55

    """

    56

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

    57

    58

    59

DataTypeRange = dict(DataTypeRange_list)

    60

    61

"""

    62

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

    63

Each block have this attributes:

    64

    - "name" : The block name

    65

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

    66

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

    67

    - "inputs" : List of the block inputs

    68

    - "outputs" : List of the block outputs

    69

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

    70

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

    71

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

    72

    - The name

    73

    - The data type

    74

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

    75

"""

    76

    77

StdBlckLibs = {libname: LoadProject(tc6fname)[0]

    78

               for libname, tc6fname in StdTC6Libs}

    79

StdBlckLst = [{"name": libname, "list":

    80

               [GetBlockInfos(pous) for pous in lib.getpous()]}

    81

              for libname, lib in StdBlckLibs.items()]

    82

    83

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

    84

#                             Test identifier

    85

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

    86

    87

IDENTIFIER_MODEL = re.compile(

    88

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

    89

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

    90

    91

    92

def TestIdentifier(identifier):

    93

    """

    94

    Test if identifier is valid

    95

    """

    96

    return IDENTIFIER_MODEL.match(identifier) is not None

    97

    98

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

    99

#                        Standard functions list generation

   100

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

   101

   102

   103

def csv_file_to_table(file):

   104

    """

   105

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

   106

    """

   107

    table = [[column.strip()

   108

              for column in line.split(';')]

   109

             for line in file.readlines()]

   110

    return table

   111

   112

   113

def find_section(section_name, table):

   114

    """

   115

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

   116

    return the matching row without first field

   117

    """

   118

    fields = [None]

   119

    while fields[0] != section_name:

   120

        fields = table.pop(0)

   121

    return fields[1:]

   122

   123

   124

def get_standard_funtions_input_variables(table):

   125

    """

   126

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

   127

    return a { ParameterName: Type, ...}

   128

    """

   129

    variables = find_section("Standard_functions_variables_types", table)

   130

    standard_funtions_input_variables = {}

   131

    fields = [True, True]

   132

    while fields[1]:

   133

        fields = table.pop(0)

   134

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

   135

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

   136

    return standard_funtions_input_variables

   137

   138

   139

def csv_input_translate(str_decl, variables, base):

   140

    """

   141

    translate .csv file input declaration into PLCOpenEditor interessting values

   142

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

   143

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

   144

    """

   145

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

   146

    params = []

   147

   148

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

   149

   150

    for param_type in decl:

   151

        if param_type in list(variables.keys()):

   152

            param_name = param_type

   153

            param_type = variables[param_type]

   154

        elif len_of_not_predifined_variable > 1:

   155

            param_name = "IN%d" % base

   156

            base += 1

   157

        else:

   158

            param_name = "IN"

   159

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

   160

    return params

   161

   162

   163

def get_standard_funtions(table):

   164

    """

   165

    Returns this kind of declaration for all standard functions

   166

   167

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

   168

                'baseinputnumber': 1,

   169

                'comment': 'Addition',

   170

                'extensible': True,

   171

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

   172

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

   173

                'name': 'ADD',

   174

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

   175

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

   176

    """

   177

   178

    variables = get_standard_funtions_input_variables(table)

   179

   180

    fonctions = find_section("Standard_functions_type", table)

   181

   182

    Standard_Functions_Decl = []

   183

    Current_section = None

   184

   185

    translate = {

   186

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

   187

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

   188

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

   189

   190

    for fields in table:

   191

        if fields[1]:

   192

            # If function section name given

   193

            if fields[0]:

   194

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

   195

                if len(words) > 1:

   196

                    section_name = words[1]

   197

                else:

   198

                    section_name = fields[0]

   199

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

   200

                Standard_Functions_Decl.append(Current_section)

   201

            if Current_section:

   202

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

   203

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

   204

                Function_decl["baseinputnumber"] = baseinputnumber

   205

                for param, value in Function_decl.items():

   206

                    if param in translate:

   207

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

   208

                Function_decl["type"] = "function"

   209

   210

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

   211

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

   212

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

   213

                else:

   214

                    input_ovrloading_types = [None]

   215

                    output_types = [None]

   216

   217

                funcdeclname_orig = Function_decl["name"]

   218

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

   219

                fdc = Function_decl["inputs"][:]

   220

                for intype in input_ovrloading_types:

   221

                    if intype is not None:

   222

                        Function_decl["inputs"] = []

   223

                        for decl_tpl in fdc:

   224

                            if IsOfType(intype, decl_tpl[1]):

   225

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

   226

                            else:

   227

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

   228

   229

                            if funcdeclname_orig.startswith('*'):

   230

                                funcdeclin = intype + '_' + funcdeclname

   231

                            else:

   232

                                funcdeclin = funcdeclname

   233

                    else:

   234

                        funcdeclin = funcdeclname

   235

   236

                    for outype in output_types:

   237

                        if outype is not None:

   238

                            decl_tpl = Function_decl["outputs"][0]

   239

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

   240

                            if funcdeclname_orig.endswith('*'):

   241

                                funcdeclout = funcdeclin + '_' + outype

   242

                            else:

   243

                                funcdeclout = funcdeclin

   244

                        else:

   245

                            funcdeclout = funcdeclin

   246

                        Function_decl["name"] = funcdeclout

   247

   248

                        # apply filter given in "filter" column

   249

                        filter_name = Function_decl["filter"]

   250

                        store = True

   251

                        for (InTypes, OutTypes) in ANY_TO_ANY_FILTERS.get(filter_name, []):

   252

                            outs = reduce(lambda a, b: a or b,

   253

                                          [IsOfType(

   254

                                              Function_decl["outputs"][0][1],

   255

                                              testtype) for testtype in OutTypes])

   256

                            inps = reduce(lambda a, b: a or b,

   257

                                          [IsOfType(

   258

                                              Function_decl["inputs"][0][1],

   259

                                              testtype) for testtype in InTypes])

   260

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

   261

                                store = True

   262

                                break

   263

                            else:

   264

                                store = False

   265

                        if store:

   266

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

   267

                            Function_decl_copy = Function_decl.copy()

   268

                            Current_section["list"].append(Function_decl_copy)

   269

            else:

   270

                raise ValueError("First function must be in a category")

   271

   272

    return Standard_Functions_Decl

   273

   274

   275

StdBlckLst.extend(get_standard_funtions(csv_file_to_table(open(StdFuncsCSV))))

   276

   277

# Dictionary to speedup block type fetching by name

   278

StdBlckDct = OrderedDict()

   279

   280

for section in StdBlckLst:

   281

    for desc in section["list"]:

   282

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

   283

        if len(words) > 1:

   284

            desc["comment"] = words[1]

   285

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

   286

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

   287

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

   288

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

   289

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

   290

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

   291

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

   292

   293

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

   294

#                            Languages Keywords

   295

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

   296

   297

# Keywords for Pou Declaration

   298

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

   299

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

   300

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

   301

for category in StdBlckLst:

   302

    for block in category["list"]:

   303

        if block["name"] not in POU_KEYWORDS:

   304

            POU_KEYWORDS.append(block["name"])

   305

   306

   307

# Keywords for Type Declaration

   308

TYPE_BLOCK_START_KEYWORDS = ["TYPE", "STRUCT"]

   309

TYPE_BLOCK_END_KEYWORDS = ["END_TYPE", "END_STRUCT"]

   310

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

   311

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

   312

   313

   314

# Keywords for Variable Declaration

   315

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

   316

VAR_BLOCK_END_KEYWORDS = ["END_VAR"]

   317

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

   318

   319

   320

# Keywords for Configuration Declaration

   321

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

   322

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

   323

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

   324

   325

# Keywords for Structured Function Chart

   326

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

   327

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

   328

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

   329

   330

   331

# Keywords for Instruction List

   332

IL_KEYWORDS = [

   333

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

   334

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

   335

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

   336

]

   337

   338

   339

# Keywords for Structured Text

   340

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

   341

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

   342

ST_KEYWORDS = [

   343

    "TRUE", "FALSE", "THEN", "OF", "TO", "BY", "DO", "DO", "UNTIL", "EXIT", "CONTINUE",

   344

    "RETURN", "NOT", "MOD", "AND", "XOR", "OR"

   345

] + ST_BLOCK_START_KEYWORDS + ST_BLOCK_END_KEYWORDS

   346

   347

# All the keywords of IEC

   348

IEC_BLOCK_START_KEYWORDS = []

   349

IEC_BLOCK_END_KEYWORDS = []

   350

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

   351

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

   352

                                                                VAR_BLOCK_START_KEYWORDS, CONFIG_BLOCK_START_KEYWORDS,

   353

                                                                SFC_BLOCK_START_KEYWORDS, ST_BLOCK_START_KEYWORDS]),

   354

                                    (IEC_BLOCK_END_KEYWORDS, [POU_BLOCK_END_KEYWORDS, TYPE_BLOCK_END_KEYWORDS,

   355

                                                              VAR_BLOCK_END_KEYWORDS, CONFIG_BLOCK_END_KEYWORDS,

   356

                                                              SFC_BLOCK_END_KEYWORDS, ST_BLOCK_END_KEYWORDS]),

   357

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

   358

                                                    SFC_KEYWORDS, IL_KEYWORDS, ST_KEYWORDS])]:

   359

    for keywords in keywords_list:

   360

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