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) 2016 Mario de Sousa (msousa@fe.up.pt)

     8

#

     9

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

    10

# it under the terms of the GNU General Public License as published by

    11

# the Free Software Foundation, either version 2 of the License, or

    12

# (at your option) any later version.

    13

#

    14

# This program is distributed in the hope that it will be useful,

    15

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

# GNU General Public License for more details.

    18

#

    19

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

    20

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

    21

#

    22

# This code is made available on the understanding that it will not be

    23

# used in safety-critical situations without a full and competent review.

    24

    25

from __future__ import absolute_import

    26

from __future__ import division

    27

from six.moves import xrange

    28

    29

# dictionary implementing:

    30

# key   - string with the description we want in the request plugin GUI

    31

# tuple - (modbus function number, request type, max count value,

    32

# data_type, bit_size)

    33

modbus_function_dict = {

    34

    "01 - Read Coils":                ('1',  'req_input', 2000, "BOOL",  1, "Q", "X", "Coil"),

    35

    "02 - Read Input Discretes":      ('2',  'req_input', 2000, "BOOL",  1, "I", "X", "Input Discrete"),

    36

    "03 - Read Holding Registers":    ('3',  'req_input',  125, "WORD", 16, "Q", "W", "Holding Register"),

    37

    "04 - Read Input Registers":      ('4',  'req_input',  125, "WORD", 16, "I", "W", "Input Register"),

    38

    "05 - Write Single coil":         ('5', 'req_output',    1, "BOOL",  1, "Q", "X", "Coil"),

    39

    "06 - Write Single Register":     ('6', 'req_output',    1, "WORD", 16, "Q", "W", "Holding Register"),

    40

    "15 - Write Multiple Coils":     ('15', 'req_output', 1968, "BOOL",  1, "Q", "X", "Coil"),

    41

    "16 - Write Multiple Registers": ('16', 'req_output',  123, "WORD", 16, "Q", "W", "Holding Register")}

    42

    43

    44

# Configuration tree value acces helper

    45

def GetCTVal(child, index):

    46

    return child.GetParamsAttributes()[0]["children"][index]["value"]

    47

    48

    49

# Configuration tree value acces helper, for multiple values

    50

def GetCTVals(child, indexes):

    51

    return map(lambda index: GetCTVal(child, index), indexes)

    52

    53

    54

def GetTCPServerNodePrinted(self, child):

    55

    """

    56

    Outputs a string to be used on C files

    57

    params: child - the correspondent subplugin in Beremiz

    58

    """

    59

    node_init_template = '''/*node %(locnodestr)s*/

    60

{"%(locnodestr)s", "%(config_name)s", "%(host)s", "%(port)s", %(slaveid)s, {naf_tcp, {.tcp = {NULL, NULL, DEF_CLOSE_ON_SILENCE}}}, -1 /* mb_nd */, 0 /* init_state */}'''

    61

    62

    location = ".".join(map(str, child.GetCurrentLocation()))

    63

    config_name, host, port, slaveid = GetCTVals(child, range(4))

    64

    if host == "#ANY#":

    65

        host = ''

    66

    # slaveid = GetCTVal(child, 2)

    67

    # if int(slaveid) not in xrange(256):

    68

        # self.GetCTRoot().logger.write_error("Error: Wrong slave ID in %s server node\nModbus Plugin C code returns empty\n"%location)

    69

        # return None

    70

    71

    node_dict = {"locnodestr": location,

    72

                 "config_name": config_name,

    73

                 "host": host,

    74

                 "port": port,

    75

                 "slaveid": slaveid}

    76

    return node_init_template % node_dict

    77

    78

    79

def GetTCPServerMemAreaPrinted(self, child, nodeid):

    80

    """

    81

    Outputs a string to be used on C files

    82

    params: child - the correspondent subplugin in Beremiz

    83

            nodeid - on C code, each request has it's own parent node (sequential, 0..NUMBER_OF_NODES)

    84

                     It's this parameter.

    85

    return: None - if any definition error found

    86

            The string that should be added on C code - if everything goes allright

    87

    """

    88

    request_dict = {}

    89

    90

    request_dict["locreqstr"] = "_".join(map(str, child.GetCurrentLocation()))

    91

    request_dict["nodeid"] = str(nodeid)

    92

    request_dict["address"] = GetCTVal(child, 2)

    93

    if int(request_dict["address"]) not in xrange(65536):

    94

        self.GetCTRoot().logger.write_error(

    95

            "Modbus plugin: Invalid Start Address in server memory area node %(locreqstr)s (Must be in the range [0..65535])\nModbus plugin: Aborting C code generation for this node\n" % request_dict)

    96

        return None

    97

    request_dict["count"] = GetCTVal(child, 1)

    98

    if int(request_dict["count"]) not in xrange(1, 65537):

    99

        self.GetCTRoot().logger.write_error(

   100

            "Modbus plugin: Invalid number of channels in server memory area node %(locreqstr)s (Must be in the range [1..65536-start_address])\nModbus plugin: Aborting C code generation for this node\n" % request_dict)

   101

        return None

   102

    if (int(request_dict["address"]) + int(request_dict["count"])) not in xrange(1, 65537):

   103

        self.GetCTRoot().logger.write_error(

   104

            "Modbus plugin: Invalid number of channels in server memory area node %(locreqstr)s (Must be in the range [1..65536-start_address])\nModbus plugin: Aborting C code generation for this node\n" % request_dict)

   105

        return None

   106

   107

    return ""

   108

   109

   110

modbus_serial_baudrate_list = [

   111

    "110", "300", "600", "1200", "2400", "4800", "9600", "19200", "38400", "57600", "115200"]

   112

modbus_serial_stopbits_list = ["1", "2"]

   113

modbus_serial_parity_dict = {"none": 0, "odd": 1, "even": 2}

   114

   115

   116

def GetRTUSlaveNodePrinted(self, child):

   117

    """

   118

    Outputs a string to be used on C files

   119

    params: child - the correspondent subplugin in Beremiz

   120

    """

   121

    node_init_template = '''/*node %(locnodestr)s*/

   122

{"%(locnodestr)s", "%(config_name)s", "%(device)s", "",%(slaveid)s, {naf_rtu, {.rtu = {NULL, %(baud)s /*baud*/, %(parity)s /*parity*/, 8 /*data bits*/, %(stopbits)s, 0 /* ignore echo */}}}, -1 /* mb_nd */, 0 /* init_state */}'''

   123

   124

    location = ".".join(map(str, child.GetCurrentLocation()))

   125

    config_name, device, baud, parity, stopbits, slaveid = GetCTVals(child, range(6))

   126

   127

    node_dict = {"locnodestr": location,

   128

                 "config_name": config_name,

   129

                 "device": device,

   130

                 "baud": baud,

   131

                 "parity": modbus_serial_parity_dict[parity],

   132

                 "stopbits": stopbits,

   133

                 "slaveid": slaveid}

   134

    return node_init_template % node_dict

   135

   136

   137

def GetRTUClientNodePrinted(self, child):

   138

    """

   139

    Outputs a string to be used on C files

   140

    params: child - the correspondent subplugin in Beremiz

   141

    """

   142

    node_init_template = '''/*node %(locnodestr)s*/

   143

{"%(locnodestr)s", "%(config_name)s", "%(device)s", "", {naf_rtu, {.rtu = {NULL, %(baud)s /*baud*/, %(parity)s /*parity*/, 8 /*data bits*/, %(stopbits)s, 0 /* ignore echo */}}}, -1 /* mb_nd */, 0 /* init_state */, %(coms_period)s /* communication period */}'''

   144

   145

    location = ".".join(map(str, child.GetCurrentLocation()))

   146

    config_name, device, baud, parity, stopbits, coms_period = GetCTVals(child, range(6))

   147

   148

    node_dict = {"locnodestr": location,

   149

                 "config_name": config_name,

   150

                 "device": device,

   151

                 "baud": baud,

   152

                 "parity": modbus_serial_parity_dict[parity],

   153

                 "stopbits": stopbits,

   154

                 "coms_period": coms_period}

   155

    return node_init_template % node_dict

   156

   157

   158

def GetTCPClientNodePrinted(self, child):

   159

    """

   160

    Outputs a string to be used on C files

   161

    params: child - the correspondent subplugin in Beremiz

   162

    """

   163

    node_init_template = '''/*node %(locnodestr)s*/

   164

{"%(locnodestr)s", "%(config_name)s", "%(host)s", "%(port)s", {naf_tcp, {.tcp = {NULL, NULL, DEF_CLOSE_ON_SILENCE}}}, -1 /* mb_nd */, 0 /* init_state */, %(coms_period)s /* communication period */, 0 /* prev_error */}'''

   165

   166

    location = ".".join(map(str, child.GetCurrentLocation()))

   167

    config_name, host, port, coms_period = GetCTVals(child, range(4))

   168

   169

    node_dict = {"locnodestr": location,

   170

                 "config_name": config_name,

   171

                 "host": host,

   172

                 "port": port,

   173

                 "coms_period": coms_period}

   174

    return node_init_template % node_dict

   175

   176

   177

def GetClientRequestPrinted(self, child, nodeid):

   178

    """

   179

    Outputs a string to be used on C files

   180

    params: child - the correspondent subplugin in Beremiz

   181

            nodeid - on C code, each request has it's own parent node (sequential, 0..NUMBER_OF_NODES)

   182

                     It's this parameter.

   183

    return: None - if any definition error found

   184

            The string that should be added on C code - if everything goes allright

   185

    """

   186

   187

    req_init_template = '''/*request %(locreqstr)s*/

   188

{"%(locreqstr)s", %(nodeid)s, %(slaveid)s, %(iotype)s, %(func_nr)s, %(address)s , %(count)s,

   189

DEF_REQ_SEND_RETRIES, 0 /* error_code */, 0 /* prev_code */, {%(timeout_s)d, %(timeout_ns)d} /* timeout */, %(write_on_change)d /* write_on_change */, 

   190

{%(buffer)s}, {%(buffer)s}}'''

   191

   192

    timeout = int(GetCTVal(child, 4))

   193

    timeout_s = timeout // 1000

   194

    timeout_ms = timeout - (timeout_s * 1000)

   195

    timeout_ns = timeout_ms * 1000000

   196

   197

    request_dict = {

   198

        "locreqstr": "_".join(map(str, child.GetCurrentLocation())),

   199

        "nodeid": str(nodeid),

   200

        "slaveid": GetCTVal(child, 1),

   201

        "address": GetCTVal(child, 3),

   202

        "count": GetCTVal(child, 2),

   203

        "write_on_change": GetCTVal(child, 5),

   204

        "timeout": timeout,

   205

        "timeout_s": timeout_s,

   206

        "timeout_ns": timeout_ns,

   207

        "buffer": ",".join(['0'] * int(GetCTVal(child, 2))),

   208

        "func_nr": modbus_function_dict[GetCTVal(child, 0)][0],

   209

        "iotype": modbus_function_dict[GetCTVal(child, 0)][1],

   210

        "maxcount": modbus_function_dict[GetCTVal(child, 0)][2]}

   211

   212

    if int(request_dict["slaveid"]) not in xrange(256):

   213

        self.GetCTRoot().logger.write_error(

   214

            "Modbus plugin: Invalid slaveID in TCP client request node %(locreqstr)s (Must be in the range [0..255])\nModbus plugin: Aborting C code generation for this node\n" % request_dict)

   215

        return None

   216

    if int(request_dict["address"]) not in xrange(65536):

   217

        self.GetCTRoot().logger.write_error(

   218

            "Modbus plugin: Invalid Start Address in TCP client request node %(locreqstr)s (Must be in the range [0..65535])\nModbus plugin: Aborting C code generation for this node\n" % request_dict)

   219

        return None

   220

    if int(request_dict["count"]) not in xrange(1, 1 + int(request_dict["maxcount"])):

   221

        self.GetCTRoot().logger.write_error(

   222

            "Modbus plugin: Invalid number of channels in TCP client request node %(locreqstr)s (Must be in the range [1..%(maxcount)s])\nModbus plugin: Aborting C code generation for this node\n" % request_dict)

   223

        return None

   224

    if (int(request_dict["address"]) + int(request_dict["count"])) not in xrange(1, 65537):

   225

        self.GetCTRoot().logger.write_error(

   226

            "Modbus plugin: Invalid number of channels in TCP client request node %(locreqstr)s (start_address + nr_channels must be less than 65536)\nModbus plugin: Aborting C code generation for this node\n" % request_dict)

   227

        return None

   228

    if (request_dict["write_on_change"] and (request_dict["iotype"] == 'req_input')):

   229

        self.GetCTRoot().logger.write_error(

   230

            "Modbus plugin: (warning) MB client request node %(locreqstr)s has option 'write_on_change' enabled.\nModbus plugin: This option will be ignored by the Modbus read function.\n" % request_dict)

   231

        # NOTE: this is only a warning (we don't wish to abort code generation) so following line must be left commented out!

   232

        # return None

   233

   234

   235

    return req_init_template % request_dict