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 3 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 map(lambda index: GetCTVal(child, index), 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", %(slaveid)s, {naf_tcp, {.tcp = {%(host)s, "%(port)s", DEF_CLOSE_ON_SILENCE}}}, -1 /* mb_nd */, 0 /* init_state */}'''

    58

    59

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

    60

    host, port, slaveid = GetCTVals(child, range(3))

    61

    if host == "#ANY#":

    62

        host = 'INADDR_ANY'

    63

    else:

    64

        host = '"' + host + '"'

    65

    # slaveid = GetCTVal(child, 2)

    66

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

    67

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

    68

        # return None

    69

    70

    node_dict = {"locnodestr": location,

    71

                 "host": host,

    72

                 "port": port,

    73

                 "slaveid": slaveid}

    74

    return node_init_template % node_dict

    75

    76

    77

def GetTCPServerMemAreaPrinted(self, child, nodeid):

    78

    """

    79

    Outputs a string to be used on C files

    80

    params: child - the correspondent subplugin in Beremiz

    81

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

    82

                     It's this parameter.

    83

    return: None - if any definition error found

    84

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

    85

    """

    86

    request_dict = {}

    87

    88

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

    89

    request_dict["nodeid"] = str(nodeid)

    90

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

    91

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

    92

        self.GetCTRoot().logger.write_error(

    93

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

    94

        return None

    95

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

    96

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

    97

        self.GetCTRoot().logger.write_error(

    98

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

    99

        return None

   100

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

   101

        self.GetCTRoot().logger.write_error(

   102

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

   103

        return None

   104

   105

    return ""

   106

   107

   108

modbus_serial_baudrate_list = [

   109

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

   110

modbus_serial_stopbits_list = ["1", "2"]

   111

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

   112

   113

   114

def GetRTUSlaveNodePrinted(self, child):

   115

    """

   116

    Outputs a string to be used on C files

   117

    params: child - the correspondent subplugin in Beremiz

   118

    """

   119

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

   120

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

   121

   122

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

   123

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

   124

   125

    node_dict = {"locnodestr": location,

   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", {naf_rtu, {.rtu = {"%(device)s", %(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 */}'''

   141

   142

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

   143

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

   144

   145

    node_dict = {"locnodestr": location,

   146

                 "device": device,

   147

                 "baud": baud,

   148

                 "parity": modbus_serial_parity_dict[parity],

   149

                 "stopbits": stopbits,

   150

                 "coms_period": coms_period}

   151

    return node_init_template % node_dict

   152

   153

   154

def GetTCPClientNodePrinted(self, child):

   155

    """

   156

    Outputs a string to be used on C files

   157

    params: child - the correspondent subplugin in Beremiz

   158

    """

   159

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

   160

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

   161

   162

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

   163

    host, port, coms_period = GetCTVals(child, range(3))

   164

   165

    node_dict = {"locnodestr": location,

   166

                 "host": host,

   167

                 "port": port,

   168

                 "coms_period": coms_period}

   169

    return node_init_template % node_dict

   170

   171

   172

def GetClientRequestPrinted(self, child, nodeid):

   173

    """

   174

    Outputs a string to be used on C files

   175

    params: child - the correspondent subplugin in Beremiz

   176

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

   177

                     It's this parameter.

   178

    return: None - if any definition error found

   179

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

   180

    """

   181

   182

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

   183

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

   184

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

   185

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

   186

   187

    timeout = int(GetCTVal(child, 4))

   188

    timeout_s = int(timeout / 1000)

   189

    timeout_ms = timeout - (timeout_s * 1000)

   190

    timeout_ns = timeout_ms * 1000000

   191

   192

    request_dict = {

   193

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

   194

        "nodeid": str(nodeid),

   195

        "slaveid": GetCTVal(child, 1),

   196

        "address": GetCTVal(child, 3),

   197

        "count": GetCTVal(child, 2),

   198

        "timeout": timeout,

   199

        "timeout_s": timeout_s,

   200

        "timeout_ns": timeout_ns,

   201

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

   202

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

   203

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

   204

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

   205

   206

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

   207

        self.GetCTRoot().logger.write_error(

   208

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

   209

        return None

   210

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

   211

        self.GetCTRoot().logger.write_error(

   212

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

   213

        return None

   214

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

   215

        self.GetCTRoot().logger.write_error(

   216

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

   217

        return None

   218

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

   219

        self.GetCTRoot().logger.write_error(

   220

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

   221

        return None

   222

   223

    return req_init_template % request_dict