mb_mst.c

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

/******************************************************************************
*
* (c) 2004 by BECK IPC GmbH
*
*******************************************************************************
*
* Module:   mb_mst.c
* Function:
*           This file provides a basic set of functions for sending
            as a Modbus rtu master several different modbus function
*           frames to a modbus slave and receiving the reply.
*           Supported functions: 1h,2h,3h,4h,5h,6h,Fh,10h,2Bh(only in parts)
*           The functions are described at the C-comment of each functions
*           At file main.c the usage of this functions is demonstrated.
*
*           Please note: The recommended modbus timing specifications for
*           sending/receiving bytes/frames via the serial line are only
*           approximately implemented.
********************************************************************************
* 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_mst.c, 3, 01.09.2005 17:13:40, Markus Bartat$
*
******************************************************************************/
/******************************************************************************
* Includes
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <mem.h>

#include "clib.h"
#include "modbus.h"
#include "mb_mst.h"
/******************************************************************************
* Constant defines
******************************************************************************/
//#define  MB_SER_DEBUG
/******************************************************************************
* Coomunication variables
******************************************************************************/
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
/******************************************************************************
 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
} ;
//******************************************************************************
//For debugging only: Print a serial modbus frame
//******************************************************************************
#ifdef MB_SER_DEBUG
static void print_mb_frame(char * msg, unsigned char * buf, int length)
{
   int i;
   printf("\r\n%s frame with length %d\r\n",msg,length);
   for(i=0;i<length;i++)
   {
      printf("%02X ",buf[i]);
   }
   RTX_Sleep_Time(50);
}
#endif
//***********************************************************
// CRC calculation routine
//***********************************************************
static unsigned int CRC16(unsigned char *puchMsg, unsigned int usDataLen)
{
  unsigned char uchCRCHi = 0xFF ; /* high byte of CRC initialized */
  unsigned char uchCRCLo = 0xFF ; /* low byte of CRC initialized */
  unsigned int  uIndex ; /* will index into CRC lookup table */

  while (usDataLen--) /* pass through message buffer */
  {
    uIndex = uchCRCHi ^ *puchMsg++ ; /* calculate the CRC */
    uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex];
    uchCRCLo = auchCRCLo[uIndex] ;
  }
  return ((uchCRCHi << 8) | uchCRCLo) ;
}
//*****************************************************************************
//Local: Receive a modbus reply frame via serial fossil
//       function is used at every of the following modbus request functions
//******************************************************************************
static int mb_ser_recv_frame(unsigned char * buf,
                             int expected_length,
                             unsigned int timeout)
{
   int byte_count=0;
   int ch;
   int tcnt=0;

   #ifdef MB_SER_DEBUG
   printf("\r\nmb_ser_recv_frame: Start expected length %d", expected_length);
   #endif

   //1. Receive first char (slave address) wait max. until timeout occurs
   do
   {
     ch=fossil_getbyte(port);
     if(ch==-1)
     {
        //wait defined interval and try to receive again
        RTX_Sleep_Time(silent_interval);
        tcnt+=silent_interval;
        if(tcnt>timeout)
        {
          #ifdef MB_SER_DEBUG
          printf("\r\nmb_ser_recv_frame: Timeout, waiting for reply");
          #endif
          return MB_ERROR;
        }
     }
     else
     {
       buf[byte_count++]=(unsigned char)ch;
     }
   }while(ch==-1);

   //wait for function code
   RTX_Sleep_Time(silent_interval);
   while(byte_count<2)
   {
     ch=fossil_getbyte(port);
     if(ch==-1)
     {
        //wait defined interval and try to receive again
        RTX_Sleep_Time(silent_interval);
        ch=fossil_getbyte(port);
        if(ch==-1)
        {
           #ifdef MB_SER_DEBUG
           printf("\r\nmb_ser_recv_frame: 1. timeout error");
           #endif
           return MB_ERROR;
        }
     }
     else
     {
       buf[byte_count++]=(unsigned char)ch;
     }
   }


   #ifdef MB_SER_DEBUG
   printf("\r\nmb_ser_recv_frame: Received: Slaveaddr %02X, Function code %02X",buf[0],buf[1]);
   #endif

   //Is it an exception reply=> reduce expected length of received fram?
   if(buf[1]&0x80)
   {
      if(buf[1]== (MB_RD_DEV_IDENT  |0x80))
         expected_length=6;  //a read id exception reply has six byte length
      else
         expected_length=5;  //length of execption fram is 5 bytes
   }

   while(byte_count<expected_length)
   {
     ch=fossil_getbyte(port);
     if(ch==-1)
     {
        //wait defined interval and try to receive again
        RTX_Sleep_Time(silent_interval);
        ch=fossil_getbyte(port);
        if(ch==-1)
        {
           #ifdef MB_SER_DEBUG
           printf("\r\nmb_ser_recv_frame: 2. timeout, frame complete??");
           #endif
           break; //assume we have the frame received complete, crc will show us , if so
        }
     }

     if(ch!=-1) //Insert byte into recvbuf
     {
        buf[byte_count++]=(unsigned char)ch;
     }
   }

   #ifdef MB_SER_DEBUG
   print_mb_frame("\r\nmb_ser_recv_frame: Received frame", buf, byte_count);
   #endif

   //Calculate crc checksum and see, if we got a complete modbus frame
   if(byte_count>=4)
   {
     if(0!=CRC16(buf,byte_count))
     {
       #ifdef MB_SER_DEBUG
       printf("\r\nReceive checksum error\r\n");
       #endif
       return MB_ERROR;
     }
     else
     {
       return MB_NO_ERROR;
     }
   }
   #ifdef MB_SER_DEBUG
   printf("\r\nInvalid frame received: Less than 4 bytes\n");
   #endif
   return MB_ERROR;
}
//******************************************************************************
// Local: Sending a serial modbus request frame via fossil
//        Function is used at every of the following modbus request functions
//******************************************************************************
static int mb_ser_send( unsigned char * buf, unsigned int length)
{
   unsigned int  result;
   unsigned int  tcnt;
   int           ch;

   fossil_purge_input(port); //clear input garbage for receiving reply
   result=
   tcnt  = 0;

   #ifdef MB_SER_DEBUG
   print_mb_frame("\r\nSending request",buf, length);
   #endif

   //Wait until block, is completely placed into rtos tx serial queue
   do
   {
        result+=fossil_writeblock(port,&buf[result],length-result);
        if(result!=length)
        {
          RTX_Sleep_Time(1);
          tcnt++;
          if(tcnt>=SEND_QUEUE_TIMEOUT)
          {
           #ifdef MB_SER_DEBUG
           printf("\r\nSend timeout");
           #endif
           return MB_ERROR;
          }
        }
        else
        {
          break;
        }
   }while(result!=length);
   //Wait until everything is out of tx queue
   fossil_flush_output(port);

   RTX_Sleep_Time(frame_wait_interval);

   //Try to receive the own frame and check, if frame was correct send
   if(rs485)
   {
      result=
      tcnt  = 0;
      while(result!=length)
      {
          ch = fossil_getbyte(port);
          if(ch==-1)
          {
             RTX_Sleep_Time(1);
             tcnt+=1;
             if(tcnt>=SEND_QUEUE_TIMEOUT)
             {
                #ifdef MB_SER_DEBUG
                printf("\r\nRS485 send failed (timeout)\r\n");
                #endif
                return MB_ERROR;

             }
          }
          else
          {
             //compare incoming character with send buffer
             if((unsigned char)ch!= buf[result++])
             {
                #ifdef MB_SER_DEBUG
                printf("\r\nRS485 send failed(no correct receive of own frame)\r\n");
                #endif
                return MB_ERROR;
             }
          }
      }
   }
   return MB_NO_ERROR;
}
/*******************************************************************************
  Init/Deinit serial port for modbus communication
  Must be called at the start of the application, before calling any other
  of the provided functions below.