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

import string

    26

import re

    27

from plcopen import LoadProject

    28

from collections import OrderedDict

    29

from definitions import *

    30

    31

TypeHierarchy = dict(TypeHierarchy_list)

    32

    33

    34

def IsOfType(type, reference):

    35

    """

    36

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

    37

    """

    38

    if reference is None:

    39

        return True

    40

    elif type == reference:

    41

        return True

    42

    else:

    43

        parent_type = TypeHierarchy[type]

    44

        if parent_type is not None:

    45

            return IsOfType(parent_type, reference)

    46

    return False

    47

    48

    49

def GetSubTypes(type):

    50

    """

    51

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

    52

    """

    53

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

    54

    55

DataTypeRange = dict(DataTypeRange_list)

    56

    57

"""

    58

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

    59

Each block have this attributes:

    60

    - "name" : The block name

    61

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

    62

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

    63

    - "inputs" : List of the block inputs

    64

    - "outputs" : List of the block outputs

    65

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

    66

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

    67

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

    68

    - The name

    69

    - The data type

    70

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

    71

"""

    72

    73

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

    74

             for libname, tc6fname in StdTC6Libs}

    75

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

    76

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

    77

             for libname, lib in StdBlckLibs.iteritems()]

    78

    79

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

    80

#                             Test identifier

    81

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

    82

    83

IDENTIFIER_MODEL = re.compile(

    84

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

    85

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

    86

    87

    88

def TestIdentifier(identifier):

    89

    """

    90

    Test if identifier is valid

    91

    """

    92

    return IDENTIFIER_MODEL.match(identifier) is not None

    93

    94

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

    95

#                        Standard functions list generation

    96

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

    97

    98

    99

def csv_file_to_table(file):

   100

    """

   101

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

   102

    """

   104

   105

   106

def find_section(section_name, table):

   107

    """

   108

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

   109

    return the matching row without first field

   110

    """

   111

    fields = [None]

   112

    while(fields[0] != section_name):

   113

        fields = table.pop(0)

   114

    return fields[1:]

   115

   116

   117

def get_standard_funtions_input_variables(table):

   118

    """

   119

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

   120

    return a { ParameterName: Type, ...}

   121

    """

   122

    variables = find_section("Standard_functions_variables_types", table)

   123

    standard_funtions_input_variables = {}

   124

    fields = [True, True]

   125

    while(fields[1]):

   126

        fields = table.pop(0)

   127

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

   128

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

   129

    return standard_funtions_input_variables

   130

   131

   132

def csv_input_translate(str_decl, variables, base):

   133

    """

   134

    translate .csv file input declaration into PLCOpenEditor interessting values

   135

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

   136

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

   137

    """

   138

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

   139

    params = []

   140

   141

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

   142

   143

    for param_type in decl:

   144

        if param_type in variables.keys():

   145

            param_name = param_type

   146

            param_type = variables[param_type]

   147

        elif len_of_not_predifined_variable > 1:

   148

            param_name = "IN%d" % base

   149

            base += 1

   150

        else:

   151

            param_name = "IN"

   152

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

   153

    return params

   154

   155

   156

def get_standard_funtions(table):

   157

    """

   158

    Returns this kind of declaration for all standard functions

   159

   160

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

   161

                'baseinputnumber': 1,

   162

                'comment': 'Addition',

   163

                'extensible': True,

   164

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

   165

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

   166

                'name': 'ADD',

   167

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

   168

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

   169

    """

   170

   171

    variables = get_standard_funtions_input_variables(table)

   172

   173

    fonctions = find_section("Standard_functions_type", table)

   174

   175

    Standard_Functions_Decl = []

   176

    Current_section = None

   177

   178

    translate = {

   179

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

   180

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

   181

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

   182

   183

    for fields in table:

   184

        if fields[1]:

   185

            # If function section name given

   186

            if fields[0]:

   187

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

   188

                if len(words) > 1:

   189

                    section_name = words[1]

   190

                else:

   191

                    section_name = fields[0]

   192

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

   193

                Standard_Functions_Decl.append(Current_section)

   194

                Function_decl_list = []

   195

            if Current_section:

   196

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

   197

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

   198

                Function_decl["baseinputnumber"] = baseinputnumber

   199

                for param, value in Function_decl.iteritems():

   200

                    if param in translate:

   201

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

   202

                Function_decl["type"] = "function"

   203

   204

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

   205

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

   206

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

   207

                else:

   208

                    input_ovrloading_types = [None]

   209

                    output_types = [None]

   210

   211

                funcdeclname_orig = Function_decl["name"]

   212

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

   213

                fdc = Function_decl["inputs"][:]

   214

                for intype in input_ovrloading_types:

   215

                    if intype is not None:

   216

                        Function_decl["inputs"] = []

   217

                        for decl_tpl in fdc:

   218

                            if IsOfType(intype, decl_tpl[1]):

   219

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

   220

                            else:

   221

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

   222

   223

                            if funcdeclname_orig.startswith('*'):

   224

                                funcdeclin = intype + '_' + funcdeclname

   225

                            else:

   226

                                funcdeclin = funcdeclname

   227

                    else:

   228

                        funcdeclin = funcdeclname

   229

   230

                    for outype in output_types:

   231

                        if outype is not None:

   232

                            decl_tpl = Function_decl["outputs"][0]

   234

                            if funcdeclname_orig.endswith('*'):

   235

                                funcdeclout =  funcdeclin + '_' + outype

   236

                            else:

   237

                                funcdeclout =  funcdeclin

   238

                        else:

   239

                            funcdeclout =  funcdeclin

   240

                        Function_decl["name"] = funcdeclout

   241

   242

                        # apply filter given in "filter" column

   243

                        filter_name = Function_decl["filter"]

   244

                        store = True

   245

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

   246

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

   247

                                       map(lambda testtype: IsOfType(

   248

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

   249

                                           testtype), OutTypes))

   250

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

   251

                                       map(lambda testtype: IsOfType(

   252

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

   253

                                           testtype), InTypes))

   254

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

   255

                                store = True

   256

                                break

   257

                            else:

   258

                                store = False

   259

                        if store:

   260

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

   261

                            Function_decl_copy = Function_decl.copy()

   262

                            Current_section["list"].append(Function_decl_copy)

   263

            else:

   264

                raise "First function must be in a category"

   265

   266

    return Standard_Functions_Decl

   267

   268

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

   269

   270

# Dictionary to speedup block type fetching by name

   271

StdBlckDct = OrderedDict()

   272

   273

for section in StdBlckLst:

   274

    for desc in section["list"]:

   275

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

   276

        if len(words) > 1:

   277

            desc["comment"] = words[1]

   278

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

   279

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

   280

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

   281

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

   282

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

   283

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

   284

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

   285

   286

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

   287

#                            Languages Keywords

   288

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

   289

   290

# Keywords for Pou Declaration

   291

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

   292

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

   293

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

   294

for category in StdBlckLst:

   295

    for block in category["list"]:

   296

        if block["name"] not in POU_KEYWORDS:

   297

            POU_KEYWORDS.append(block["name"])

   298

   299

   300

# Keywords for Type Declaration

   301

TYPE_BLOCK_START_KEYWORDS = ["TYPE", "STRUCT"]

   302

TYPE_BLOCK_END_KEYWORDS = ["END_TYPE", "END_STRUCT"]

   303

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

   304

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

   305

   306

   307

# Keywords for Variable Declaration

   308

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

   309

VAR_BLOCK_END_KEYWORDS = ["END_VAR"]

   310

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

   311

   312

   313

# Keywords for Configuration Declaration

   314

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

   315

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

   316

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

   317

   318

# Keywords for Structured Function Chart

   319

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

   320

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

   321

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

   322

   323

   324

# Keywords for Instruction List

   325

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

   326

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

   327

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

   328

   329

   330

# Keywords for Structured Text

   331

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

   332

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

   333

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

   334

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

   335

   336

# All the keywords of IEC

   337

IEC_BLOCK_START_KEYWORDS = []

   338

IEC_BLOCK_END_KEYWORDS = []

   339

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

   340

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

   341

                                                                VAR_BLOCK_START_KEYWORDS, CONFIG_BLOCK_START_KEYWORDS,

   342

                                                                SFC_BLOCK_START_KEYWORDS, ST_BLOCK_START_KEYWORDS]),

   343

                                    (IEC_BLOCK_END_KEYWORDS, [POU_BLOCK_END_KEYWORDS, TYPE_BLOCK_END_KEYWORDS,

   344

                                                              VAR_BLOCK_END_KEYWORDS, CONFIG_BLOCK_END_KEYWORDS,

   345

                                                              SFC_BLOCK_END_KEYWORDS, ST_BLOCK_END_KEYWORDS]),

   346

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

   347

                                                    SFC_KEYWORDS, IL_KEYWORDS, ST_KEYWORDS])]:

   348

    for keywords in keywords_list:

   349

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