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

    26

# dictionary implementing:

    27

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

    28

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

    29

# data_type, bit_size)

    30

modbus_function_dict = {

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

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

    38

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

    39

    40

    41

# Configuration tree value acces helper

    42

def GetCTVal(child, index):

    43

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

    44

    45

    46

# Configuration tree value acces helper, for multiple values

    47

def GetCTVals(child, indexes):

    48

    return [GetCTVal(child, index) for index in indexes]

    49

    50

    51

def GetTCPServerNodePrinted(self, child):

    52

    """

    53

    Outputs a string to be used on C files

    54

    params: child - the correspondent subplugin in Beremiz

    55

    """

    56

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

    57

{"%(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 */}'''

    58

    59

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

    60

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

    61

    if host == "#ANY#":

    62

        host = ''

    63

    # slaveid = GetCTVal(child, 2)

    64

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

    65

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

    66

        # return None

    67

    68

    node_dict = {"locnodestr": location,

    69

                 "config_name": config_name,

    70

                 "host": host,

    71

                 "port": port,

    72

                 "slaveid": slaveid}

    73

    return node_init_template % node_dict

    74

    75

    76

def GetTCPServerMemAreaPrinted(self, child, nodeid):

    77

    """

    78

    Outputs a string to be used on C files

    79

    params: child - the correspondent subplugin in Beremiz

    80

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

    81

                     It's this parameter.

    82

    return: None - if any definition error found

    83

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

    84

    """

    85

    request_dict = {}

    86

    87

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

    88

    request_dict["nodeid"] = str(nodeid)

    89

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

    90

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

    91

        self.GetCTRoot().logger.write_error(

    92

            "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)

    93

        return None

    94

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

    95

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

    96

        self.GetCTRoot().logger.write_error(

    97

            "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)

    98

        return None

    99

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

   100

        self.GetCTRoot().logger.write_error(

   101

            "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)

   102

        return None

   103

   104

    return ""

   105

   106

   107

modbus_serial_baudrate_list = [

   108

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

   109

modbus_serial_stopbits_list = ["1", "2"]

   110

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

   111

   112

   113

def GetRTUSlaveNodePrinted(self, child):

   114

    """

   115

    Outputs a string to be used on C files

   116

    params: child - the correspondent subplugin in Beremiz

   117

    """

   118

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

   119

{"%(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 */}'''

   120

   121

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

   122

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

   123

   124

    node_dict = {"locnodestr": location,

   125

                 "config_name": config_name,

   126

                 "device": device,

   127

                 "baud": baud,

   128

                 "parity": modbus_serial_parity_dict[parity],

   129

                 "stopbits": stopbits,

   130

                 "slaveid": slaveid}

   131

    return node_init_template % node_dict

   132

   133

   134

def GetRTUClientNodePrinted(self, child):

   135

    """

   136

    Outputs a string to be used on C files

   137

    params: child - the correspondent subplugin in Beremiz

   138

    """

   139

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

   140

{"%(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  (ms)*/, %(coms_delay)s /* inter request delay (ms)*/, 0 /* prev_error */}'''

   141

   142

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

   143

    config_name, device, baud, parity, stopbits, coms_period, coms_delay = GetCTVals(child, list(range(7)))

   144

   145

    node_dict = {"locnodestr": location,

   146

                 "config_name": config_name,

   147

                 "device": device,

   148

                 "baud": baud,

   149

                 "parity": modbus_serial_parity_dict[parity],

   150

                 "stopbits": stopbits,

   151

                 "coms_period": coms_period,

   152

                 "coms_delay": coms_delay}

   153

    return node_init_template % node_dict

   154

   155

   156

def GetTCPClientNodePrinted(self, child):

   157

    """

   158

    Outputs a string to be used on C files

   159

    params: child - the correspondent subplugin in Beremiz

   160

    """

   161

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

   162

{"%(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 (ms)*/, %(coms_delay)s /* inter request delay (ms)*/, 0 /* prev_error */}'''

   163

   164

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

   165

    config_name, host, port, coms_period, coms_delay = GetCTVals(child, list(range(5)))

   166

   167

    node_dict = {"locnodestr": location,

   168

                 "config_name": config_name,

   169

                 "host": host,

   170

                 "port": port,

   171

                 "coms_period": coms_period,

   172

                 "coms_delay": coms_delay}

   173

    return node_init_template % node_dict

   174

   175

   176

def GetClientRequestPrinted(self, child, nodeid):

   177

    """

   178

    Outputs a string to be used on C files

   179

    params: child - the correspondent subplugin in Beremiz

   180

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

   181

                     It's this parameter.

   182

    return: None - if any definition error found

   183

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

   184

    """

   185

   186

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

   187

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

   188

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

   189

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

   190

   191

    timeout = int(GetCTVal(child, 4))

   192

    timeout_s = timeout // 1000

   193

    timeout_ms = timeout - (timeout_s * 1000)

   194

    timeout_ns = timeout_ms * 1000000

   195

   196

    request_dict = {

   197

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

   198

        "nodeid": str(nodeid),

   199

        "slaveid": GetCTVal(child, 1),

   200

        "address": GetCTVal(child, 3),

   201

        "count": GetCTVal(child, 2),

   202

        "write_on_change": GetCTVal(child, 5),

   203

        "timeout": timeout,

   204

        "timeout_s": timeout_s,

   205

        "timeout_ns": timeout_ns,

   206

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

   207

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

   208

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

   209

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

   210

   211

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

   212

        self.GetCTRoot().logger.write_error(

   213

            "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)

   214

        return None

   215

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

   216

        self.GetCTRoot().logger.write_error(

   217

            "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)

   218

        return None

   219

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

   220

        self.GetCTRoot().logger.write_error(

   221

            "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)

   222

        return None

   223

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

   224

        self.GetCTRoot().logger.write_error(

   225

            "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)

   226

        return None

   227

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

   228

        self.GetCTRoot().logger.write_error(

   229

            "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)

   230

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

   231

        # return None

   232

   233

   234

    return req_init_template % request_dict