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

from __future__ import absolute_import

    27

import string

    28

import re

    29

from collections import OrderedDict

    30

    31

from plcopen.plcopen import LoadProject

    32

from plcopen.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 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.iteritems()]

    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

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

   108

   109

   110

def find_section(section_name, table):

   111

    """

   112

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

   113

    return the matching row without first field

   114

    """

   115

    fields = [None]

   116

    while fields[0] != section_name:

   117

        fields = table.pop(0)

   118

    return fields[1:]

   119

   120

   121

def get_standard_funtions_input_variables(table):

   122

    """

   123

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

   124

    return a { ParameterName: Type, ...}

   125

    """

   126

    variables = find_section("Standard_functions_variables_types", table)

   127

    standard_funtions_input_variables = {}

   128

    fields = [True, True]

   129

    while fields[1]:

   130

        fields = table.pop(0)

   131

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

   132

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

   133

    return standard_funtions_input_variables

   134

   135

   136

def csv_input_translate(str_decl, variables, base):

   137

    """

   138

    translate .csv file input declaration into PLCOpenEditor interessting values

   139

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

   140

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

   141

    """

   142

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

   143

    params = []

   144

   145

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

   146

   147

    for param_type in decl:

   148

        if param_type in variables.keys():

   149

            param_name = param_type

   150

            param_type = variables[param_type]

   151

        elif len_of_not_predifined_variable > 1:

   152

            param_name = "IN%d" % base

   153

            base += 1

   154

        else:

   155

            param_name = "IN"

   156

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

   157

    return params

   158

   159

   160

def get_standard_funtions(table):

   161

    """

   162

    Returns this kind of declaration for all standard functions

   163

   164

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

   165

                'baseinputnumber': 1,

   166

                'comment': 'Addition',

   167

                'extensible': True,

   168

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

   169

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

   170

                'name': 'ADD',

   171

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

   172

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

   173

    """

   174

   175

    variables = get_standard_funtions_input_variables(table)

   176

   177

    fonctions = find_section("Standard_functions_type", table)

   178

   179

    Standard_Functions_Decl = []

   180

    Current_section = None

   181

   182

    translate = {

   183

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

   184

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

   185

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

   186

   187

    for fields in table:

   188

        if fields[1]:

   189

            # If function section name given

   190

            if fields[0]:

   191

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

   192

                if len(words) > 1:

   193

                    section_name = words[1]

   194

                else:

   195

                    section_name = fields[0]

   196

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

   197

                Standard_Functions_Decl.append(Current_section)

   198

            if Current_section:

   199

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

   200

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

   201

                Function_decl["baseinputnumber"] = baseinputnumber

   202

                for param, value in Function_decl.iteritems():

   203

                    if param in translate:

   204

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

   205

                Function_decl["type"] = "function"

   206

   207

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

   208

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

   209

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

   210

                else:

   211

                    input_ovrloading_types = [None]

   212

                    output_types = [None]

   213

   214

                funcdeclname_orig = Function_decl["name"]

   215

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

   216

                fdc = Function_decl["inputs"][:]

   217

                for intype in input_ovrloading_types:

   218

                    if intype is not None:

   219

                        Function_decl["inputs"] = []

   220

                        for decl_tpl in fdc:

   221

                            if IsOfType(intype, decl_tpl[1]):

   222

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

   223

                            else:

   224

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

   225

   226

                            if funcdeclname_orig.startswith('*'):

   227

                                funcdeclin = intype + '_' + funcdeclname

   228

                            else:

   229

                                funcdeclin = funcdeclname

   230

                    else:

   231

                        funcdeclin = funcdeclname

   232

   233

                    for outype in output_types:

   234

                        if outype is not None:

   235

                            decl_tpl = Function_decl["outputs"][0]

   236

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

   237

                            if funcdeclname_orig.endswith('*'):

   238

                                funcdeclout = funcdeclin + '_' + outype

   239

                            else:

   240

                                funcdeclout = funcdeclin

   241

                        else:

   242

                            funcdeclout = funcdeclin

   243

                        Function_decl["name"] = funcdeclout

   244

   245

                        # apply filter given in "filter" column

   246

                        filter_name = Function_decl["filter"]

   247

                        store = True

   248

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

   249

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

   250

                                          map(lambda testtype: IsOfType(

   251

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

   252

                                              testtype), OutTypes))

   253

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

   254

                                          map(lambda testtype: IsOfType(

   255

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

   256

                                              testtype), InTypes))

   257

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

   258

                                store = True

   259

                                break

   260

                            else:

   261

                                store = False

   262

                        if store:

   263

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

   264

                            Function_decl_copy = Function_decl.copy()

   265

                            Current_section["list"].append(Function_decl_copy)

   266

            else:

   267

                raise "First function must be in a category"

   268

   269

    return Standard_Functions_Decl

   270

   271

   272

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

   273

   274

# Dictionary to speedup block type fetching by name

   275

StdBlckDct = OrderedDict()

   276

   277

for section in StdBlckLst:

   278

    for desc in section["list"]:

   279

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

   280

        if len(words) > 1:

   281

            desc["comment"] = words[1]

   282

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

   283

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

   284

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

   285

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

   286

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

   287

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

   288

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

   289

   290

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

   291

#                            Languages Keywords

   292

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

   293

   294

# Keywords for Pou Declaration

   295

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

   296

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

   297

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

   298

for category in StdBlckLst:

   299

    for block in category["list"]:

   300

        if block["name"] not in POU_KEYWORDS:

   301

            POU_KEYWORDS.append(block["name"])

   302

   303

   304

# Keywords for Type Declaration

   305

TYPE_BLOCK_START_KEYWORDS = ["TYPE", "STRUCT"]

   306

TYPE_BLOCK_END_KEYWORDS = ["END_TYPE", "END_STRUCT"]

   307

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

   308

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

   309

   310

   311

# Keywords for Variable Declaration

   312

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

   313

VAR_BLOCK_END_KEYWORDS = ["END_VAR"]

   314

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

   315

   316

   317

# Keywords for Configuration Declaration

   318

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

   319

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

   320

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

   321

   322

# Keywords for Structured Function Chart

   323

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

   324

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

   325

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

   326

   327

   328

# Keywords for Instruction List

   329

IL_KEYWORDS = [

   330

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

   331

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

   332

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

   333

]

   334

   335

   336

# Keywords for Structured Text

   337

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

   338

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

   339

ST_KEYWORDS = [

   340

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

   341

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

   342

] + ST_BLOCK_START_KEYWORDS + ST_BLOCK_END_KEYWORDS

   343

   344

# All the keywords of IEC

   345

IEC_BLOCK_START_KEYWORDS = []

   346

IEC_BLOCK_END_KEYWORDS = []

   347

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

   348

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

   349

                                                                VAR_BLOCK_START_KEYWORDS, CONFIG_BLOCK_START_KEYWORDS,

   350

                                                                SFC_BLOCK_START_KEYWORDS, ST_BLOCK_START_KEYWORDS]),

   351

                                    (IEC_BLOCK_END_KEYWORDS, [POU_BLOCK_END_KEYWORDS, TYPE_BLOCK_END_KEYWORDS,

   352

                                                              VAR_BLOCK_END_KEYWORDS, CONFIG_BLOCK_END_KEYWORDS,

   353

                                                              SFC_BLOCK_END_KEYWORDS, ST_BLOCK_END_KEYWORDS]),

   354

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

   355

                                                    SFC_KEYWORDS, IL_KEYWORDS, ST_KEYWORDS])]:

   356

    for keywords in keywords_list:

   357

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