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 = [

   328

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

   329

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

   330

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

   331

]

   332

   333

   334

# Keywords for Structured Text

   335

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

   336

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

   337

ST_KEYWORDS = [

   338

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

   339

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

   340

] + ST_BLOCK_START_KEYWORDS + ST_BLOCK_END_KEYWORDS

   341

   342

# All the keywords of IEC

   343

IEC_BLOCK_START_KEYWORDS = []

   344

IEC_BLOCK_END_KEYWORDS = []

   345

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

   346

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

   347

                                                                VAR_BLOCK_START_KEYWORDS, CONFIG_BLOCK_START_KEYWORDS,

   348

                                                                SFC_BLOCK_START_KEYWORDS, ST_BLOCK_START_KEYWORDS]),

   349

                                    (IEC_BLOCK_END_KEYWORDS, [POU_BLOCK_END_KEYWORDS, TYPE_BLOCK_END_KEYWORDS,

   350

                                                              VAR_BLOCK_END_KEYWORDS, CONFIG_BLOCK_END_KEYWORDS,

   351

                                                              SFC_BLOCK_END_KEYWORDS, ST_BLOCK_END_KEYWORDS]),

   352

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

   353

                                                    SFC_KEYWORDS, IL_KEYWORDS, ST_KEYWORDS])]:

   354

    for keywords in keywords_list:

   355

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