1

/* File generated by Beremiz (PlugGenerate_C method of modbus Plugin instance) */

     2

     3

/*

     4

 * Copyright (c) 2016 Mario de Sousa (msousa@fe.up.pt)

     5

 *

     6

 * This file is part of the Modbus library for Beremiz and matiec.

     7

 *

     8

 * This Modbus library is free software: you can redistribute it and/or modify

     9

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

    10

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

    11

 * (at your option) any later version.

    12

 *

    13

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

    14

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser 

    16

 * General Public License for more details.

    17

 *

    18

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

    19

 * along with this Modbus library.  If not, see <http://www.gnu.org/licenses/>.

    20

 *

    21

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

    22

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

    23

 */

    24

    25

#include "mb_addr.h"

    26

#include "mb_tcp_private.h"

    27

#include "mb_master_private.h"

    28

    29

    30

    31

#define DEF_REQ_SEND_RETRIES 0

    32

    33

    34

#define MODBUS_PARAM_STRING_SIZE 64

    35

    36

    37

  // Used by the Modbus server node

    38

#define MEM_AREA_SIZE 65536

    39

typedef struct{

    40

	    u16		ro_bits [MEM_AREA_SIZE];

    41

	    u16		rw_bits [MEM_AREA_SIZE];

    42

	    u16		ro_words[MEM_AREA_SIZE];

    43

	    u16		rw_words[MEM_AREA_SIZE];

    53

	} server_mem_t;

    54

    55

    56

/*

    57

 * Beremiz has a program to run on the PLC (Beremiz_service.py)

    58

 * to handle downloading of compiled programs, start/stop of PLC, etc.

    59

 * (see runtime/PLCObject.py for start/stop, loading, ...)

    60

 * 

    61

 * This service also includes a web server to access PLC state (start/stop)

    62

 * and to change some basic confiuration parameters.

    63

 * (see runtime/NevowServer.py for the web server)

    64

 * 

    65

 * The web server allows for extensions, where additional configuration

    66

 * parameters may be changed on the running/downloaded PLC.

    67

 * Modbus plugin also comes with an extension to the web server, through

    68

 * which the basic Modbus plugin configuration parameters may be changed

    69

 *

    70

 * This means that most values in the server_node_t and client_node_t

    71

 * may be changed after the co,piled code (.so file) is loaded into 

    72

 * memory, and before the code starts executing.

    73

 * Since the we will also want to change the host and port (TCP) and the

    74

 * serial device (RTU) at this time, it is best if we allocate memory for

    75

 * these strings that may be overwritten by the web server (i.e., do not use

    76

 * const strings) in the server_node_t and client_node_t structures.

    77

 *

    78

 * The following structure members

    79

 *    - node_addr_t.addr.tcp.host

    80

 *    - node_addr_t.addr.tcp.service  (i.e. the port)

    81

 *    - node_addr_t.addr.rtu.device

    82

 * are all char *, and do not allocate memory for the strings.

    83

 * 

    84

 * We therefore include two generic char arrays, str1 and str2,

    85

 * that will store the above strings, and the C code will initiliaze

    86

 * the node_addre_t.addr string pointers to these strings.

    87

 * i.e., either addr.rtu.device will point to str1,

    88

 *          or

    89

 *        addr.tcp.host and addr.tcp.service 

    90

 *        will point to str1 and str2 respectively

    91

 */

    92

typedef struct{

    93

	    const char *location;

    94

        const char *config_name;

    95

              char  str1[MODBUS_PARAM_STRING_SIZE];

    96

              char  str2[MODBUS_PARAM_STRING_SIZE]; 

    97

	    u8		slave_id;

    98

	    node_addr_t	node_address;

    99

	    int		mb_nd;      // modbus library node used for this server 

   100

	    int		init_state; // store how far along the server's initialization has progressed

   103

	    pthread_t	thread_id;  // thread handling this server

   104

	    server_mem_t	mem_area;

   105

	} server_node_t;

   106

   107

   108

  // Used by the Modbus client node

   109

typedef struct{

   110

	    const char *location;

   111

        const char *config_name;

   112

              char  str1[MODBUS_PARAM_STRING_SIZE];

   113

              char  str2[MODBUS_PARAM_STRING_SIZE]; 

   114

	    node_addr_t	node_address;

   115

	    int		mb_nd;      // modbus library node used for this client

   116

	    int		init_state; // store how far along the client's initialization has progressed

   117

	    u64		comm_period;// period to use when periodically sending requests to remote server

   118

	    int		prev_error; // error code of the last printed error message (0 when no error) 

   119

	    pthread_t   thread_id;  // thread handling all communication for this client node

   120

	    timer_t      timer_id;  // timer used to periodically activate this client node's thread

   121

	    pthread_mutex_t mutex;  // mutex to be used with the following condition variable

   122

        pthread_cond_t  condv;  // used to signal the client thread when to start new modbus transactions

   123

        int       execute_req;  /* used, in association with condition variable,  

   124

                                 *   to signal when to send the modbus request to the server

   125

                                 * Note that we cannot simply rely on the condition variable to signal

   126

                                 *   when to activate the client thread, as the call to 

   127

                                 *   pthread_cond_wait() may return without having been signaled!

   128

                                 *   From the manual:

   129

                                 *      Spurious  wakeups  from  the

   130

                                 *      pthread_cond_timedwait() or pthread_cond_wait()  functions  may  occur.

   131

                                 *      Since  the  return from pthread_cond_timedwait() or pthread_cond_wait()

   132

                                 *      does not imply anything about the value of this predicate,  the  predi-

   133

                                 *      cate should be re-evaluated upon such return.

   134

                                 */

   135

        int      periodic_act;  /* (boolen) flag will be set when the client node's thread was activated 

   136

                                 * (by signaling the above condition variable) by the periodic timer.

   137

                                 * Note that this same thread may also be activated (condition variable is signaled)

   138

                                 * by other sources, such as when the user program requests that a specific 

   139

                                 * client MB transation be executed (flag_exec_req in client_request_t)

   140

                                 */

   141

	} client_node_t;

   142

   143

   144

  // Used by the Modbus client plugin

   145

typedef enum {

   146

	    req_input,

   147

	    req_output,

   148

	    no_request		/* just for tests to quickly disable a request */

   149

	} iotype_t;

   150

   151

#define REQ_BUF_SIZE 2000

   152

typedef struct{

   153

	    const char *location;

   154

	    int		client_node_id;

   155

	    u8		slave_id;

   156

	    iotype_t	req_type;

   157

	    u8		mb_function;

   158

	    u16		address;

   159

	    u16		count;

   160

	    int		retries;

   161

	    u8		mb_error_code; // modbus      error code (if any) of last executed request

   162

	    u8		tn_error_code; // transaction error code (if any) of last executed request

   163

	    int		prev_error; // error code of the last printed error message (0 when no error) 

   164

	    struct timespec resp_timeout;

   165

	    u8		write_on_change; // boolean flag. If true => execute MB request when data to send changes

   166

	      // buffer used to store located PLC variables

   167

	    u16		plcv_buffer[REQ_BUF_SIZE];

   168

	      // buffer used to store data coming from / going to server

   169

	    u16		coms_buffer[REQ_BUF_SIZE]; 

   170

	    pthread_mutex_t coms_buf_mutex; // mutex to access coms_buffer[]

   171

          /* boolean flag that will be mapped onto a (BOOL) located variable 

   172

           * (u8 because IEC 61131-3 BOOL are mapped onto u8 in C code! )

   173

           *    -> allow PLC program to request when to start the MB transaction

   174

           *    -> will be reset once the MB transaction has completed

   175

           */

   176

        u8     flag_exec_req;  

   177

          /* flag that works in conjunction with flag_exec_req

   178

           * (does not really need to be u8 as it is not mapped onto a located variable. )

   179

           *    -> used by internal logic to indicate that the client thread 

   180

           *       that will be executing the MB transaction

   181

           *       requested by flag exec_req has already been activated.

   182

           *    -> will be reset once the MB transaction has completed

   183

           */

   184

        u8     flag_exec_started;  

   185

          /* flag that will be mapped onto a (BYTE) located variable 

   186

           * (u8 because the flag is a BYTE! )

   187

           *    -> will store the result of the last executed MB transaction

   188

           *         1 -> error accessing IP network, or serial interface

   189

           *         2 -> reply received from server was an invalid frame

   190

           *         3 -> server did not reply before timeout expired

   191

           *         4 -> server returned a valid Modbus error frame

   192

           *    -> will be reset (set to 0) once this MB transaction has completed sucesfully

   193

           * 

   194

           * In other words, this variable is a copy of tn_error_code, reset after each request attempt completes.

   195

           * We map this copy (instead of tn_error_code) onto a located variable in case the user program decides

   196

           * to overwrite its value and mess up the plugin logic.

   197

           */

   198

        u8      flag_tn_error_code;  

   199

          /* flag that will be mapped onto a (BYTE) located variable 

   200

           * (u8 because the flag is a BYTE! )

   201

           *    -> if flag_tn_error_code is 4, this flag will store the MB error code returned by the MB server in a MB error frame

   202

           *    -> will be reset (set to 0) once this MB transaction has completed succesfully

   203

           * 

   204

           * In other words, this variable is a copy of mb_error_code, reset after each request attempt completes.

   205

           * We map this copy (instead of mb_error_code) onto a located variable in case the user program decides

   206

           * to overwrite its value and mess up the plugin logic.

   207

           */

   208

        u8      flag_mb_error_code;  

   209

	} client_request_t;

   210

   211

   212

/* The total number of nodes, needed to support _all_ instances of the modbus plugin */

   213

#define TOTAL_TCPNODE_COUNT       %(total_tcpnode_count)s

   214

#define TOTAL_RTUNODE_COUNT       %(total_rtunode_count)s

   215

#define TOTAL_ASCNODE_COUNT       %(total_ascnode_count)s

   216

   217

/* Values for instance %(locstr)s of the modbus plugin */

   218

#define MAX_NUMBER_OF_TCPCLIENTS  %(max_remote_tcpclient)s

   219

   220

#define NUMBER_OF_TCPSERVER_NODES %(tcpserver_node_count)s

   221

#define NUMBER_OF_TCPCLIENT_NODES %(tcpclient_node_count)s

   222

#define NUMBER_OF_TCPCLIENT_REQTS %(tcpclient_reqs_count)s

   223

   224

#define NUMBER_OF_RTUSERVER_NODES %(rtuserver_node_count)s

   225

#define NUMBER_OF_RTUCLIENT_NODES %(rtuclient_node_count)s

   226

#define NUMBER_OF_RTUCLIENT_REQTS %(rtuclient_reqs_count)s

   227

   228

#define NUMBER_OF_ASCIISERVER_NODES %(ascserver_node_count)s

   229

#define NUMBER_OF_ASCIICLIENT_NODES %(ascclient_node_count)s

   230

#define NUMBER_OF_ASCIICLIENT_REQTS %(ascclient_reqs_count)s

   231

   232

#define NUMBER_OF_SERVER_NODES (NUMBER_OF_TCPSERVER_NODES + \

   233

                                NUMBER_OF_RTUSERVER_NODES + \

   234

                                NUMBER_OF_ASCIISERVER_NODES)

   235

   236

#define NUMBER_OF_CLIENT_NODES (NUMBER_OF_TCPCLIENT_NODES + \

   237

                                NUMBER_OF_RTUCLIENT_NODES + \

   238

                                NUMBER_OF_ASCIICLIENT_NODES)

   239

   240

#define NUMBER_OF_CLIENT_REQTS (NUMBER_OF_TCPCLIENT_REQTS + \

   241

                                NUMBER_OF_RTUCLIENT_REQTS + \

   242

                                NUMBER_OF_ASCIICLIENT_REQTS)

   243

   244

   245

/*initialization following all parameters given by user in application*/

   246

   247

static client_node_t		client_nodes[NUMBER_OF_CLIENT_NODES] = {

   248

%(client_nodes_params)s

   249

};

   250

   251

   252

static client_request_t	client_requests[NUMBER_OF_CLIENT_REQTS] = {

   253

%(client_req_params)s

   254

};

   255

   256

   257

static server_node_t		server_nodes[NUMBER_OF_SERVER_NODES] = {

   258

%(server_nodes_params)s

   259

}

   260

;

   261

   262

/*******************/

   263

/*located variables*/

   264

/*******************/

   265

   266

%(loc_vars)s

   267