UART_TX_Buffer[3+i] = byte_store ;

            }
         UART_TX_Buffer[1] = UART_RX_buf[1] ;
         modbusSendUARTPacket( (BYTE)(3+byte_cnt) ) ;
         return;

         /******************************************************************/
         /*       FUNCTION CODE 0X05 -> WRITE COIL                         */
         /******************************************************************/
      case MODBUS_WRITE_COIL :

         {
            if ( !temp_md )
               {
               modbusReturnException (ILLEGAL_DATA_ADDRESS) ;
               return ;
               }
         }

         for ( i = 0 ; i < (BYTE)WRITE_COIL_RESPONSE_LENGTH ; i++ )
            {
            UART_TX_Buffer[i] = UART_RX_buf[i] ;
            }
         UART_TX_Buffer[1] = UART_RX_buf[1] ;
         modbusSendUARTPacket( WRITE_COIL_RESPONSE_LENGTH ) ;
         return ;

         /******************************************************************/
         /*       FUNCTION CODE 0X06 -> WRITE REGISTER                     */
         /******************************************************************/
      case MODBUS_WRITE_REGISTER:
         {

            {
               if ( !temp_md )
                  {
                  modbusReturnException (ILLEGAL_DATA_ADDRESS) ;
                  return ;
                  }
            }

            for ( i = 0 ; i < (BYTE)WRITE_COIL_RESPONSE_LENGTH ; i++ )
               {
               UART_TX_Buffer[i] = UART_RX_buf[i] ;
               }
            UART_TX_Buffer[1] = UART_RX_buf[1] ;
            modbusSendUARTPacket( WRITE_COIL_RESPONSE_LENGTH ) ;
            return ;
         }
         //break;

         /******************************************************************/
         /*       FUNCTION CODE 0X04  -> READ REGISTER                     */
         /******************************************************************/
      case MODBUS_READ_INPUTREGISTERS :
         {
            BYTE local_length;

            i = 3;
            local_length=(BYTE)(in_buffer.length);

            for ( byte_cnt = 0 ; byte_cnt < local_length ; byte_cnt++ )
               {
               if ( !temp_md )
                  {
                  modbusReturnException (ILLEGAL_DATA_ADDRESS) ;
                  return ;
                  }

               UART_TX_Buffer[i] = (BYTE)(temp_md->data>>8) ; //high 8 bits

               UART_TX_Buffer[i+1] = (BYTE)(temp_md->data) ;  // low 8 bits

               i = (BYTE)(i + 2) ;
               in_buffer.address++ ;
               if ( in_buffer.address >= in_buffer.length )
                  {
                  break ;
                  }
               temp_md=modbusFetchData();
               }

            UART_TX_Buffer[1] = UART_RX_buf[1] ;             // copy function code
            UART_TX_Buffer[2] = (BYTE)(UART_RX_buf[5] * 2) ; // num data bytes

            modbusSendUARTPacket( (BYTE)(3 + UART_TX_Buffer[2]) ) ;
         }
         return ;
      default:
         break;
      }
}


/*============================================================================*/
// Make sure that the modbus poll received is complete as a message.
BYTE modbusPollReceiveComplete ( VOID )
{
   BYTE   target,count_tmp ;
   UINT16 temp_code1,temp_code2,temp_code3 ;
   UINT16 check ;

   get_PICUART_data () ;

   /******************************************************************/
   /*      LESS THAN FOUR BYTES RECEIVED CMPLT_HOPE                  */
   /******************************************************************/
   if ( UART_rcv_count < (BYTE)4 )  //received less than 4 bytes
      {
      return CMPLT_HOPE ; // hope yet
      }

   /******************************************************************/
   /*      CHECK FOR CORRECT FUNCTION CODE                           */
   /******************************************************************/
   switch ( UART_RX_buf[1] )
      {
      case MODBUS_READ_COILS :
      case MODBUS_READ_DISCRETEINPUTS :
      case MODBUS_READ_INPUTREGISTERS :
      case MODBUS_WRITE_COIL :
      case MODBUS_WRITE_REGISTER :
         target = 6 ;
         break ;
      default :
         return CMPLT_NO_HOPE ;
      }

   /******************************************************************/
   /*      HANDLES RESPONSES FROM OTHER SERVERS                      */
   /******************************************************************/
   if ( UART_rcv_count == target )
      {
      temp_code1 = UART_RX_buf[target-2] ;
      temp_code2 = (UINT16) (temp_code1 << 8) ;
      temp_code1 = UART_RX_buf[target-1] ;
      temp_code3 = (UINT16)(temp_code2|temp_code1) ;
      if ( modrtuChecksum ( UART_RX_buf, (BYTE)(target-2)) == temp_code3 )
         {
         return CMPLT_COMPLETE;
         }
      }

   /******************************************************************/
   /*      CHECK FOR CORRECT MESSAGE LENGTH                          */
   /******************************************************************/
   temp_code1 = (UINT16)(target + 2) ;
   count_tmp=(BYTE)temp_code1;
   if ( UART_rcv_count < count_tmp )
      {
      return CMPLT_HOPE ;
      }

   /******************************************************************/
   /*      CHECK FOR CHECKSUM                                        */
   /******************************************************************/
   check = modrtuChecksum ( UART_RX_buf, target ) ;

   temp_code1 = UART_RX_buf[target] ;
   temp_code2 = (UINT16) (temp_code1 << 8) ;
   temp_code1 = UART_RX_buf[target+1] ;
   temp_code3 = (UINT16)(temp_code2|temp_code1) ;
   if ( check == (UINT16) ( temp_code3 ) )
      {
      return CMPLT_COMPLETE ;
      }

   return CMPLT_NO_HOPE ;

}

/*============================================================================*/

VOID clr_rx ( VOID)
{
   UART_rcv_count = 0;
}


/*============================================================================*/
// Initiate the modbus buffers
VOID modbus_init ( VOID )
{
   BYTE i ;

   clr_rx () ;
   for ( i = 0 ; i < (BYTE)MX_RX_TX_BUFFERSIZE ; i++ )
      {
      UART_RX_buf[i]=0;
      UART_TX_Buffer[i]=0;
      }
}


/*============================================================================*/
// Extract characters from the UART buffer
VOID get_PICUART_data ( VOID)
{
   CHAR ch ;
   // this function reads data from uart circular buffer into UART_RX_buf

   while ( sioapi_ixrx ( P6720SER2 ) )
      {
      ch = (CHAR)sioapi_getch( P6720SER2 ) ;
      UART_RX_buf[UART_rcv_count++]=(BYTE)ch;
      }
}

/*=========================================================================*/
// Check the modbus address
BYTE modbusCheckAddress( VOID )
{
   BYTE id_temp;
   id_temp= (BYTE)Get_Modbus_Node_ID();
   if ( UART_RX_buf[0] == id_temp )
      {
      return TRUE;
      }
   return FALSE;
}
/*============================================================================*/
// In the event of the message being incomplete give up one character and recheck the message
VOID modbusGiveUpCharacter( VOID )
{
   BYTE i;
   for ( i = 1 ; i < UART_rcv_count ; i++ )
      {
      UART_RX_buf[i-1] = UART_RX_buf[i] ;
      }
   UART_rcv_count--;
   if ( UART_rcv_count==(BYTE)0 )
      {
      modbusReturnException (ILLEGAL_DATA_ADDRESS) ;
      return ;
      }
}
/*============================================================================*/
// Extract relevant data from the message received from the client
BYTE modbusParseMessage( VOID )
{
   BYTE basic_function=0;

   in_buffer.node_id= UART_RX_buf[0];
   in_buffer.function=  UART_RX_buf[1];
   in_buffer.address = (UINT16)(((UINT16)(UART_RX_buf[2]) << 8)|((UINT16)(UART_RX_buf[3])));
   switch ( in_buffer.function )
      {
      case MODBUS_READ_COILS:
      case MODBUS_READ_DISCRETEINPUTS:
      case MODBUS_READ_INPUTREGISTERS:
         in_buffer.length  = (UINT16)(((UINT16)(UART_RX_buf[4]) << 8)|((UINT16)(UART_RX_buf[5])));;
         basic_function=READ;
         break;
      case MODBUS_WRITE_COIL:
      case MODBUS_WRITE_REGISTER:
         in_buffer.data = (UINT16)(((UINT16)(UART_RX_buf[4]) << 8)|((UINT16)(UART_RX_buf[5])));;
         basic_function=WRITE;
         break;
      default:
         break;
      }
   in_buffer.checksum= (UINT16) ((UINT16)(UART_RX_buf[6] << 8) | UART_RX_buf[7] ) ;

   return basic_function;
}
/*============================================================================*/
// Returns a map descriptor containing the data required
MAP_DESC_TYP *modbusFetchData( VOID )
{
   MAP_DESC_TYP *temp_md;
   temp_md=find_map_desc_with_data(in_buffer.function,in_buffer.address);
   return temp_md;
}

/*============================================================================*/
// Return a map descriptor that the data will be stored to
MAP_DESC_TYP *modbusStoreData( VOID )
{
   MAP_DESC_TYP *temp_md;
   temp_md=0;
   if ( in_buffer.function==(BYTE)MODBUS_WRITE_COIL )
      {
      if ( in_buffer.data==(UINT16)COIL_ON )
         {
         temp_md=store_data_to_data_array(in_buffer.function,in_buffer.address,ON);
         }
      else if ( in_buffer.data==(UINT16)COIL_OFF )
         {
         temp_md=store_data_to_data_array(in_buffer.function,in_buffer.address,OFF);
         }
      }
   else
      {
      temp_md=store_data_to_data_array(in_buffer.function,in_buffer.address,in_buffer.data);
      }
   return temp_md;
}