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

    61

    62

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

    63

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

    64

    if host == "#ANY#":

    65

        host = 'INADDR_ANY'

    66

    else:

    67

        host = '"' + host + '"'

    68

    # slaveid = GetCTVal(child, 2)

    69

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

    70

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

    71

        # return None

    72

    73

    node_dict = {"locnodestr": location,

    74

                 "host": host,

    75

                 "port": port,

    76

                 "slaveid": slaveid}

    77

    return node_init_template % node_dict

    78

    79

    80

def GetTCPServerMemAreaPrinted(self, child, nodeid):

    81

    """

    82

    Outputs a string to be used on C files

    83

    params: child - the correspondent subplugin in Beremiz

    84

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

    85

                     It's this parameter.

    86

    return: None - if any definition error found

    87

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

    88

    """

    89

    request_dict = {}

    90

    91

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

    92

    request_dict["nodeid"] = str(nodeid)

    93

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

    94

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

    95

        self.GetCTRoot().logger.write_error(

    96

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

    97

        return None

    98

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

    99

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

   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

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

   104

        self.GetCTRoot().logger.write_error(

   105

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

   106

        return None

   107

   108

    return ""

   109

   110

   111

modbus_serial_baudrate_list = [

   112

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

   113

modbus_serial_stopbits_list = ["1", "2"]

   114

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

   115

   116

   117

def GetRTUSlaveNodePrinted(self, child):

   118

    """

   119

    Outputs a string to be used on C files

   120

    params: child - the correspondent subplugin in Beremiz

   121

    """

   122

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

   123

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

   124

   125

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

   126

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

   127

   128

    node_dict = {"locnodestr": location,

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

   144

   145

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

   146

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

   147

   148

    node_dict = {"locnodestr": location,

   149

                 "device": device,

   150

                 "baud": baud,

   151

                 "parity": modbus_serial_parity_dict[parity],

   152

                 "stopbits": stopbits,

   153

                 "coms_period": coms_period}

   154

    return node_init_template % node_dict

   155

   156

   157

def GetTCPClientNodePrinted(self, child):

   158

    """

   159

    Outputs a string to be used on C files

   160

    params: child - the correspondent subplugin in Beremiz

   161

    """

   162

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

   163

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

   164

   165

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

   166

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

   167

   168

    node_dict = {"locnodestr": location,

   169

                 "host": host,

   170

                 "port": port,

   171

                 "coms_period": coms_period}

   172

    return node_init_template % node_dict

   173

   174

   175

def GetClientRequestPrinted(self, child, nodeid):

   176

    """

   177

    Outputs a string to be used on C files

   178

    params: child - the correspondent subplugin in Beremiz

   179

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

   180

                     It's this parameter.

   181

    return: None - if any definition error found

   182

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

   183

    """

   184

   185

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

   186

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

   187

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

   188

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

   189

   190

    timeout = int(GetCTVal(child, 4))

   191

    timeout_s = timeout // 1000

   192

    timeout_ms = timeout - (timeout_s * 1000)

   193

    timeout_ns = timeout_ms * 1000000

   194

   195

    request_dict = {

   196

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

   197

        "nodeid": str(nodeid),

   198

        "slaveid": GetCTVal(child, 1),

   199

        "address": GetCTVal(child, 3),

   200

        "count": GetCTVal(child, 2),

   201

        "timeout": timeout,

   202

        "timeout_s": timeout_s,

   203

        "timeout_ns": timeout_ns,

   204

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

   205

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

   206

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

   207

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

   208

   209

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

   210

        self.GetCTRoot().logger.write_error(

   211

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

   212

        return None

   213

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

   214

        self.GetCTRoot().logger.write_error(

   215

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

   216

        return None

   217

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

   218

        self.GetCTRoot().logger.write_error(

   219

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

   220

        return None

   221

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

   222

        self.GetCTRoot().logger.write_error(

   223

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

   224

        return None

   225

   226

    return req_init_template % request_dict