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];

    44

            /* Two flags to count the number of Modbus requests (read and write) we have 

    45

             * successfully received from any remote Modbus master.

    46

             * Two boolean flags that are set whenever we successfully process a

    47

             * Modbus request sent from a remote client.

    48

             * These flags will be mapped onto located variables

    49

             * so the user's IEC 61131-3 code can check whether we are being

    50

             * polled by a Modbus master.

    51

             * The counters will roll over to 0 upon reaching maximum value.

    52

             * The user will probably periodically reset the boolean flags to false,

    53

             * and use this as a communication timeout 

    54

             * (when it remains false in two consecutive periods)

    55

             * 

    56

             * u8  for BOOL  variable/flag

    57

             * u32 for UDINT variable/counter

    58

             */

    59

        u8   flag_write_req_flag;

    60

        u8   flag_read_req_flag;

    61

        u32  flag_write_req_counter;

    62

        u32  flag_read_req_counter;

    63

	} server_mem_t;

    64

    65

    66

/*

    67

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

    68

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

    69

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

    70

 * 

    71

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

    72

 * and to change some basic confiuration parameters.

    73

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

    74

 * 

    75

 * The web server allows for extensions, where additional configuration

    76

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

    77

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

    78

 * which the basic Modbus plugin configuration parameters may be changed

    79

 *

    80

 * This means that most values in the server_node_t and client_node_t

    81

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

    82

 * memory, and before the code starts executing.

    83

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

    84

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

    85

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

    86

 * const strings) in the server_node_t and client_node_t structures.

    87

 *

    88

 * The following structure members

    89

 *    - node_addr_t.addr.tcp.host

    90

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

    91

 *    - node_addr_t.addr.rtu.device

    92

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

    93

 * 

    94

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

    95

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

    96

 * the node_addre_t.addr string pointers to these strings.

    97

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

    98

 *          or

    99

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

   100

 *        will point to str1 and str2 respectively

   101

 */

   102

typedef struct{

   103

	    const char *location;

   104

        const char *config_name;

   105

              char  str1[MODBUS_PARAM_STRING_SIZE];

   106

              char  str2[MODBUS_PARAM_STRING_SIZE]; 

   107

	    u8		slave_id;

   108

	    node_addr_t	node_address;

   109

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

   110

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

   111

            /* entries from this point forward are not statically initialized when the variable is declared */

   112

            /* they will be initialized by the  code itself in the init() function */

   113

	    pthread_t	thread_id;  // thread handling this server

   114

	    server_mem_t	mem_area;

   115

	} server_node_t;

   116

   117

   118

  // Used by the Modbus client node

   119

typedef struct{

   120

	    const char *location;

   121

        const char *config_name;

   122

              char  str1[MODBUS_PARAM_STRING_SIZE];

   123

              char  str2[MODBUS_PARAM_STRING_SIZE]; 

   124

	    node_addr_t	node_address;

   125

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

   126

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

   127

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

   128

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

   129

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

   130

	    pthread_t	timer_thread_id;  // thread handling periodical timer for this client node

   131

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

   132

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

   133

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

   134

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

   135

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

   136

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

   137

                                 *   pthread_cond_wait() may return without having been signaled!

   138

                                 *   From the manual:

   139

                                 *      Spurious  wakeups  from  the

   140

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

   141

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

   142

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

   143

                                 *      cate should be re-evaluated upon such return.

   144

                                 */

   145

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

   146

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

   147

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

   148

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

   149

                                 * client MB transation be executed (flag_exec_req in client_request_t)

   150

                                 */

   151

	} client_node_t;

   152

   153

   154

  // Used by the Modbus client plugin

   155

typedef enum {

   156

	    req_input,

   157

	    req_output,

   158

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

   159

	} iotype_t;

   160

   161

#define REQ_BUF_SIZE 2000

   162

typedef struct{

   163

	    const char *location;

   164

	    int		client_node_id;

   165

	    u8		slave_id;

   166

	    iotype_t	req_type;

   167

	    u8		mb_function;

   168

	    u16		address;

   169

	    u16		count;

   170

	    int		retries;

   171

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

   172

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

   173

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

   174

	    struct timespec resp_timeout;

   175

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

   176

	      // buffer used to store located PLC variables

   177

	    u16		plcv_buffer[REQ_BUF_SIZE];

   178

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

   179

	    u16		coms_buffer[REQ_BUF_SIZE]; 

   180

	    pthread_mutex_t coms_buf_mutex; // mutex to access coms_buffer[]

   181

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

   182

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

   183

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

   184

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

   185

           */

   186

        u8     flag_exec_req;  

   187

          /* flag that works in conjunction with flag_exec_req

   188

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

   189

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

   190

           *       that will be executing the MB transaction

   191

           *       requested by flag exec_req has already been activated.

   192

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

   193

           */

   194

        u8     flag_exec_started;  

   195

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

   196

           * (u8 because the flag is a BYTE! )

   197

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

   198

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

   199

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

   200

           *         3 -> server did not reply before timeout expired

   201

           *         4 -> server returned a valid Modbus error frame

   202

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

   203

           * 

   204

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

   205

           * We map this copy (instead of tn_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_tn_error_code;  

   209

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

   210

           * (u8 because the flag is a BYTE! )

   211

           *    -> 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

   212

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

   213

           * 

   214

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

   215

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

   216

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

   217

           */

   218

        u8      flag_mb_error_code;  

   219

	} client_request_t;

   220

   221

   222

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

   223

#define TOTAL_TCPNODE_COUNT       %(total_tcpnode_count)s

   224

#define TOTAL_RTUNODE_COUNT       %(total_rtunode_count)s

   225

#define TOTAL_ASCNODE_COUNT       %(total_ascnode_count)s

   226

   227

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

   228

#define MAX_NUMBER_OF_TCPCLIENTS  %(max_remote_tcpclient)s

   229

   230

#define NUMBER_OF_TCPSERVER_NODES %(tcpserver_node_count)s

   231

#define NUMBER_OF_TCPCLIENT_NODES %(tcpclient_node_count)s

   232

#define NUMBER_OF_TCPCLIENT_REQTS %(tcpclient_reqs_count)s

   233

   234

#define NUMBER_OF_RTUSERVER_NODES %(rtuserver_node_count)s

   235

#define NUMBER_OF_RTUCLIENT_NODES %(rtuclient_node_count)s

   236

#define NUMBER_OF_RTUCLIENT_REQTS %(rtuclient_reqs_count)s

   237

   238

#define NUMBER_OF_ASCIISERVER_NODES %(ascserver_node_count)s

   239

#define NUMBER_OF_ASCIICLIENT_NODES %(ascclient_node_count)s

   240

#define NUMBER_OF_ASCIICLIENT_REQTS %(ascclient_reqs_count)s

   241

   242

#define NUMBER_OF_SERVER_NODES (NUMBER_OF_TCPSERVER_NODES + \

   243

                                NUMBER_OF_RTUSERVER_NODES + \

   244

                                NUMBER_OF_ASCIISERVER_NODES)

   245

   246

#define NUMBER_OF_CLIENT_NODES (NUMBER_OF_TCPCLIENT_NODES + \

   247

                                NUMBER_OF_RTUCLIENT_NODES + \

   248

                                NUMBER_OF_ASCIICLIENT_NODES)

   249

   250

#define NUMBER_OF_CLIENT_REQTS (NUMBER_OF_TCPCLIENT_REQTS + \

   251

                                NUMBER_OF_RTUCLIENT_REQTS + \

   252

                                NUMBER_OF_ASCIICLIENT_REQTS)

   253

   254

   255

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

   256

   257

static client_node_t		client_nodes[NUMBER_OF_CLIENT_NODES] = {

   258

%(client_nodes_params)s

   259

};

   260

   261

   262

static client_request_t	client_requests[NUMBER_OF_CLIENT_REQTS] = {

   263

%(client_req_params)s

   264

};

   265

   266

   267

static server_node_t		server_nodes[NUMBER_OF_SERVER_NODES] = {

   268

%(server_nodes_params)s

   269

}

   270

;

   271

   272

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

   273

/*located variables*/

   274

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

   275

   276

%(loc_vars)s

   277