mb_slv.c

modbus的c语言版本应用于dos下

/******************************************************************************
*
* (c) 2004 by BECK IPC GmbH
*
*******************************************************************************
* Module:   mb_slv.c
*
* Function: This program provides a serial modbus rtu slave for SC12/DK40 SC13/DK50.
*           It shall be used as a template for building own serial modbus slave
*           applications on IPC@CHIP based devices.
*           The slaves executes(serves)incoming modbus requests, according to the
*           DK60/DK50/DK40 register and coil definition below.
*           The application programmer shall feel free to modify,expand and improve this
*           example for his own modbus slave application.
*
*           For understanding the source code and using it for own application the
*           following premises are required:
*           1. Good knowledge about the modbus communication protocol
*           2. Careful reading and understanding of this example program
*
*           Required hardware/software for testing:
*           1. DK60/SC1x3,DK50/SC13 or DK40/SC12 as modbus rtu slave(server), running this program
*           2. DK60/SC1x3,DK50/SC13 or DK40/SC12 as modbus rtu master(client), running the program mb_mst.exe
*           3. Both targets must be connected via RS232 nullmodem cable or RS485 connection
*
*           The implementation based on the follwing documents from modbus.org
*           Please note: The server uses only a subset of the specified modbus features
*           1. Modbus over serial line Specification & Implementation V1.0
*           2. Modbus application protocol specification V1.1
*
*           Main files of this project:
*           1. Modbus.h  :  Contains several modbus specific defines
*           2. Mb_slv.c:  Contains the modbus server initialzation
                            (serial port settings,...),
*                           and the general parts for receiving/executing
                            an incoming modbus client request and sending of
                            the reply.
*           3. Mb_dev.c  :  Basic functions for handle the different types of incoming
*                           modbus requests. Inside of the several function handlers
*                           the DK40/DK50/DK60 specific register/coil read/write functions
*                           are inserted, according to the DKxx demo modbus
*                           register and coil definition below.
*                           Implemented modbus function codes:
*                           01, 02, 05, 15, 04, 03, 06 , 43 (only in parts)
*
*           4. Mb_dkxx.c : Contains our DK40/DK50 specfic functions. which are called
*                          inside of the modbus handler functions implemented at mb_dev.c.
*
*            Program parameters:
*            Usage   : mb_slv   port  address baudrate   parity   ser_mode
*            Port    : serial port  0: EXT      1: COM
*            Address : Own slave address (1-247)
*            Parity  : serial parity settings:  0: None    1: Odd     2: Even
*            Ser_Mode: serial mode: 0: RS232 with RTS/CTS flow
*                                   1: RS232 no flowctrl
*                                   2: RS485
*
*            Example : mb_slv  1  2  19200   0   0
*            To exit the modbus server it is necessary to reboot the IPC@CHIP
*
*            Please note: The recommended modbus timing specifications for sending/receiving
*            bytes/frames via the serial line are only approximately implemented.
********************************************************************************
*           DKxx Modbus  demo holding register definition
*           Register address     Access         Meaning
*               00                 R/W          DKxx 8Bit IO port at IO addr 600h/c00h
*                                               (on DK40 only Bit 6-0 available)
*               01                 R/W          16 Bit variable, for
*                                               demonstration purpose only
*               02                 R/W          16 Bit counter variable, for
*                                               demonstration purpose only, counter
*                                               is automatically incremented by a RTOS tiner
*               03                 R/W          another 16 Bit counter variable, for
*                                               demonstration purpose only, counter
*                                               is automatically changed by a RTOS timer
*
*           DKxx Modbus  demo input register definition
*           Register address     Access         Meaning
*               00                 R            DKxx 8Bit I port at IO addr 600h/c00h
*                                               (on DK40 only Bit 6-0 available)
*               01                 R            16 Bit counter variable, for
*                                               demonstration purpose only, counter
*                                               is automatically incremented by a RTOS
*               02                 R            16 Bit counter variable, for
*                                               demonstration purpose only, counter
*                                               is automatically changed by a RTOS timer
********************************************************************************
*           DKxx Modbus  demo coil  definition
*           Register address     Access         Meaning
*               00                 R/W          DKxx/SC1x PIO 3
*               01                 R/W          DKxx/SC1x PIO 13
*               02                 R/W          Bit 0 of  mb_dkxx_var (Holding reg var 01)
*               03                 R/W          Bit 1 of  mb_dkxx_var
*               04                 R/W          Bit 2 of  mb_dkxx_var
*               05                 R/W          Bit 3 of  mb_dkxx_var
*               06                 R/W          Bit 4 of  mb_dkxx_var
*               07                 R/W          Bit 5 of  mb_dkxx_var
*               08                 R/W          Bit 6 of  mb_dkxx_var
*               09                 R/W          Bit 7 of  mb_dkxx_var
*               10                 R/W          Bit 8 of  mb_dkxx_var
*               11                 R/W          Bit 9 of  mb_dkxx_var
*               12                 R/W          Bit 10 of  mb_dkxx_var
*               13                 R/W          Bit 11 of  mb_dkxx_var
*               14                 R/W          Bit 12 of  mb_dkxx_var
********************************************************************************
*           DKxx Modbus  demo discrete input  definition
*           Register address     Access         Meaning
*               00                 R          Bit 0 of DKxx IO port 0x600/C00
*               01                 R          Bit 1 of DKxx IO port 0x600/C00
*               02                 R          Bit 2 of DKxx IO port 0x600/C00
*               03                 R          Bit 3 of DKxx IO port 0x600/C00
*               04                 R          Bit 4 of DKxx IO port 0x600/C00
*               05                 R          Bit 5 of DKxx IO port 0x600/C00
*               06                 R          Bit 6 of DKxx IO port 0x600/C00
********************************************************************************
* Disclaimer: This program is an example and should be used as such.
*             If you wish to use this program or parts of it in your application,
*             you must validate the code yourself. BECK IPC GmbH can not be held
*             responsible for the correct functioning or coding of this example.
*******************************************************************************
*
* $Header: mb_slv.c, 5, 02.09.2005 11:07:30, Markus Bartat$
*
******************************************************************************/

/******************************************************************************
* Includes
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <mem.h>

#include "clib.h"
#include "modbus.h"
#include "mb_dev.h"


/******************************************************************************
* Constant defines
******************************************************************************/
#define SEND_QUEUE_TIMEOUT       50
#define MB_RS485                  2
#define MB_RS232_NONE             1
#define MB_RS232_HWFLOW           0

//#define  MB_SER_DEBUG
/******************************************************************************
* Global variables
******************************************************************************/
unsigned char slave_address;
long          baudrate;
unsigned char serial_mode;
unsigned char parity;
unsigned int  timeout_inside_frame;
unsigned int  delay_after_frame;
int           port;
unsigned char rs485=0;

unsigned int silent_interval;      //Max. wait time for chars inside of receiving a frame
unsigned int frame_wait_interval;  //Min. wait time between sending two frames

unsigned char mb_ser_request_buf[MB_SER_MAX_BUF];
unsigned char mb_ser_response_buf[MB_SER_MAX_BUF];
/******************************************************************************
* Table of CRC values for high杘rder byte
******************************************************************************/
static const unsigned char auchCRCHi[] = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40
} ;
/******************************************************************************
 Table of CRC values for low杘rder byte
******************************************************************************/
static const unsigned char auchCRCLo[] = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
0x40
} ;
/******************************************************************************
//Usage message
******************************************************************************/
void usage(void)
{
   printf("\r\nInvalid or missing parameters!"
          "\r\nUsage   : mb_slv   port address baudrate   parity   ser_mode\r\n"
          "\r\nPort    : 0: EXT      1: COM"
          "\r\nAddress : 1 .. 247"
          "\r\nParity  : 0: None    1: Odd     2: Even"
          "\r\nSer_Mode: 0: RS232 with RTS/CTS flow   1: RS232 no flowctrl    2: RS485\r\n"
          "\r\nExample : mb_slv   0   2   19200   0   0\r\n");
}
/******************************************************************************
//Reading/analyze arguments
******************************************************************************/
int parse_args(int argc, char *argv[])
{
   int result=0;
   int tmp_value;

   if(argc!=6)
   {
     result=-1;
   }
   else
   {
     //parse port
     port = atoi(argv[1]);
     if(port>1)
     {
       result=-1;
       goto END_PARSE_ARGS;
     }

     //parse slave address
     tmp_value = atoi(argv[2]);
     if((tmp_value<MB_SER_SLAVE_ADDR_MIN) || (tmp_value>MB_SER_SLAVE_ADDR_MAX))
     {
        result=-1;
        goto END_PARSE_ARGS;
     }
     slave_address=(unsigned char)tmp_value;
     //parse baudrate
     baudrate = strtol(argv[3],NULL,10);
     if((baudrate==0) || (baudrate > 230400L))
     {
       result=-1;
       goto END_PARSE_ARGS;
     }
     //parse parity
     tmp_value = atoi(argv[4]);
     if((tmp_value < 0) || (tmp_value>2))
     {
       result=-1;
       goto END_PARSE_ARGS;
     }
     parity=(unsigned char)tmp_value;