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

    56

DataTypeRange = dict(DataTypeRange_list)

    57

    58

"""

    59

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

    60

Each block have this attributes:

    61

    - "name" : The block name

    62

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

    63

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

    64

    - "inputs" : List of the block inputs

    65

    - "outputs" : List of the block outputs

    66

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

    67

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

    68

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

    69

    - The name

    70

    - The data type

    71

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

    72

"""

    73

    74

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

    75

             for libname, tc6fname in StdTC6Libs}

    76

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

    77

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

    78

             for libname, lib in StdBlckLibs.iteritems()]

    79

    80

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

    81

#                             Test identifier

    82

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

    83

    84

IDENTIFIER_MODEL = re.compile(

    85

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

    86

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

    87

    88

    89

def TestIdentifier(identifier):

    90

    """

    91

    Test if identifier is valid

    92

    """

    93

    return IDENTIFIER_MODEL.match(identifier) is not None

    94

    95

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

    96

#                        Standard functions list generation

    97

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

    98

    99

   100

def csv_file_to_table(file):

   101

    """

   102

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

   103

    """

   104

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

   105

   106

   107

def find_section(section_name, table):

   108

    """

   109

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

   110

    return the matching row without first field

   111

    """

   112

    fields = [None]

   113

    while(fields[0] != section_name):

   114

        fields = table.pop(0)

   115

    return fields[1:]

   116

   117

   118

def get_standard_funtions_input_variables(table):

   119

    """

   120

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

   121

    return a { ParameterName: Type, ...}

   122

    """

   123

    variables = find_section("Standard_functions_variables_types", table)

   124

    standard_funtions_input_variables = {}

   125

    fields = [True, True]

   126

    while(fields[1]):

   127

        fields = table.pop(0)

   128

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

   129

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

   130

    return standard_funtions_input_variables

   131

   132

   133

def csv_input_translate(str_decl, variables, base):

   134

    """

   135

    translate .csv file input declaration into PLCOpenEditor interessting values

   136

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

   137

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

   138

    """

   139

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

   140

    params = []

   141

   142

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

   143

   144

    for param_type in decl:

   145

        if param_type in variables.keys():

   146

            param_name = param_type

   147

            param_type = variables[param_type]

   148

        elif len_of_not_predifined_variable > 1:

   149

            param_name = "IN%d" % base

   150

            base += 1

   151

        else:

   152

            param_name = "IN"

   153

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

   154

    return params

   155

   156

   157

def get_standard_funtions(table):

   158

    """

   159

    Returns this kind of declaration for all standard functions

   160

   161

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

   162

                'baseinputnumber': 1,

   163

                'comment': 'Addition',

   164

                'extensible': True,

   165

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

   166

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

   167

                'name': 'ADD',

   168

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

   169

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

   170

    """

   171

   172

    variables = get_standard_funtions_input_variables(table)

   173

   174

    fonctions = find_section("Standard_functions_type", table)

   175

   176

    Standard_Functions_Decl = []

   177

    Current_section = None

   178

   179

    translate = {

   180

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

   181

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

   182

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

   183

   184

    for fields in table:

   185

        if fields[1]:

   186

            # If function section name given

   187

            if fields[0]:

   188

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

   189

                if len(words) > 1:

   190

                    section_name = words[1]

   191

                else:

   192

                    section_name = fields[0]

   193

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

   194

                Standard_Functions_Decl.append(Current_section)

   195

                Function_decl_list = []

   196

            if Current_section:

   197

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

   198

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

   199

                Function_decl["baseinputnumber"] = baseinputnumber

   200

                for param, value in Function_decl.iteritems():

   201

                    if param in translate:

   202

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

   203

                Function_decl["type"] = "function"

   204

   205

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

   206

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

   207

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

   208

                else:

   209

                    input_ovrloading_types = [None]

   210

                    output_types = [None]

   211

   212

                funcdeclname_orig = Function_decl["name"]

   213

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

   214

                fdc = Function_decl["inputs"][:]

   215

                for intype in input_ovrloading_types:

   216

                    if intype is not None:

   217

                        Function_decl["inputs"] = []

   218

                        for decl_tpl in fdc:

   219

                            if IsOfType(intype, decl_tpl[1]):

   220

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

   221

                            else:

   222

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

   223

   224

                            if funcdeclname_orig.startswith('*'):

   225

                                funcdeclin = intype + '_' + funcdeclname

   226

                            else:

   227

                                funcdeclin = funcdeclname

   228

                    else:

   229

                        funcdeclin = funcdeclname

   230

   231

                    for outype in output_types:

   232

                        if outype is not None:

   233

                            decl_tpl = Function_decl["outputs"][0]

   234

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

   235

                            if funcdeclname_orig.endswith('*'):

   236

                                funcdeclout =  funcdeclin + '_' + outype

   237

                            else:

   238

                                funcdeclout =  funcdeclin

   239

                        else:

   240

                            funcdeclout =  funcdeclin

   241

                        Function_decl["name"] = funcdeclout

   242

   243

                        # apply filter given in "filter" column

   244

                        filter_name = Function_decl["filter"]

   245

                        store = True

   246

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

   247

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

   248

                                       map(lambda testtype: IsOfType(

   249

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

   250

                                           testtype), OutTypes))

   251

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

   252

                                       map(lambda testtype: IsOfType(

   253

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

   254

                                           testtype), InTypes))

   255

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

   256

                                store = True

   257

                                break

   258

                            else:

   259

                                store = False

   260

                        if store:

   261

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

   262

                            Function_decl_copy = Function_decl.copy()

   263

                            Current_section["list"].append(Function_decl_copy)

   264

            else:

   265

                raise "First function must be in a category"

   266

   267

    return Standard_Functions_Decl

   268

   269

   270

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

   271

   272

# Dictionary to speedup block type fetching by name

   273

StdBlckDct = OrderedDict()

   274

   275

for section in StdBlckLst:

   276

    for desc in section["list"]:

   277

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

   278

        if len(words) > 1:

   279

            desc["comment"] = words[1]

   280

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

   281

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

   282

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

   283

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

   284

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

   285

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

   286

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

   287

   288

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

   289

#                            Languages Keywords

   290

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

   291

   292

# Keywords for Pou Declaration

   293

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

   294

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

   295

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

   296

for category in StdBlckLst:

   297

    for block in category["list"]:

   298

        if block["name"] not in POU_KEYWORDS:

   299

            POU_KEYWORDS.append(block["name"])

   300

   301

   302

# Keywords for Type Declaration

   303

TYPE_BLOCK_START_KEYWORDS = ["TYPE", "STRUCT"]

   304

TYPE_BLOCK_END_KEYWORDS = ["END_TYPE", "END_STRUCT"]

   305

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

   306

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

   307

   308

   309

# Keywords for Variable Declaration

   310

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

   311

VAR_BLOCK_END_KEYWORDS = ["END_VAR"]

   312

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

   313

   314

   315

# Keywords for Configuration Declaration

   316

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

   317

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

   318

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

   319

   320

# Keywords for Structured Function Chart

   321

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

   322

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

   323

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

   324

   325

   326

# Keywords for Instruction List

   327

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

   328

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

   329

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

   330

   331

   332

# Keywords for Structured Text

   333

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

   334

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

   335

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

   336

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

   337

   338

# All the keywords of IEC

   339

IEC_BLOCK_START_KEYWORDS = []

   340

IEC_BLOCK_END_KEYWORDS = []

   341

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

   342

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

   343

                                                                VAR_BLOCK_START_KEYWORDS, CONFIG_BLOCK_START_KEYWORDS,

   344

                                                                SFC_BLOCK_START_KEYWORDS, ST_BLOCK_START_KEYWORDS]),

   345

                                    (IEC_BLOCK_END_KEYWORDS, [POU_BLOCK_END_KEYWORDS, TYPE_BLOCK_END_KEYWORDS,

   346

                                                              VAR_BLOCK_END_KEYWORDS, CONFIG_BLOCK_END_KEYWORDS,

   347

                                                              SFC_BLOCK_END_KEYWORDS, ST_BLOCK_END_KEYWORDS]),

   348

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

   349

                                                    SFC_KEYWORDS, IL_KEYWORDS, ST_KEYWORDS])]:

   350

    for keywords in keywords_list:

   351

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