modbus_client.c

modbus 源代码,RS485 通信,实现PC与RTU通信

         if ( i == (BYTE)MX_DI )
            {
            poll_control++;
            goto RTICK ;
            }

         temp_md=&discrete_inputs_map[discrete_input_read];
         poll_control++;

         return temp_md;
         //break;

      case 4:
         /******************************************************************/
         /*      READ INPUT REGISTERS                                      */
         /******************************************************************/

         for ( i=0; i<(BYTE)MX_REG; i++ )
            {
            // Wrap
            if ( (BYTE)register_read >= (BYTE)MX_REG ) register_read = 0 ;
            if ( register_map[register_read].function==(BYTE)MODBUS_READ_INPUTREGISTERS )
               {
               break;
               }
            register_read++;
            }

         if ( i == (BYTE)MX_REG )
            {
            poll_control=0 ;
            goto RTICK ;
            }

         temp_md=&register_map[register_read];
         poll_control=0;

         return temp_md;

      default :
         goto RTICK ;
      }

}

/*============================================================================*/
// Handle the response from the server
VOID parse_reponse_and_store_data ( VOID )
{
   BYTE function ;
   BYTE i ;
   BYTE node_id = UART_RX_buf[0];

   function = UART_RX_buf[1];

   switch ( function )
      {
      case MODBUS_READ_COILS          :
         {
            /******************************************************************/
            /*      READ COILS                                                */
            /******************************************************************/
            UINT16 value   = (UINT16)(((UINT16)(UART_RX_buf[3]) << 8)|((UINT16)(UART_RX_buf[4])));;

            for ( i = 0 ; i < (BYTE)MX_COILS ; i++ )
               {
               if ( coil_map[i].node_id==coil_map[coil_read].node_id &&
                    coil_map[i].address == coil_map[coil_read].address )
                  {
                  break;
                  }
               }
            if ( i == (BYTE)MX_COILS )
               {
               return;
               }
            coil_read++ ;
            da_put_BIT(&coil_map[i],value);
         }
         break ;

      case MODBUS_READ_DISCRETEINPUTS :
         {
            /******************************************************************/
            /*      READ DISCRETE INPUTS                                      */
            /******************************************************************/
            UINT16 value   =  (UINT16)(((UINT16)(UART_RX_buf[3]) << 8)|((UINT16)(UART_RX_buf[4]))); ;

            for ( i = 0 ; i < (BYTE)MX_DI ; i++ )
               {
               if ( discrete_inputs_map[i].node_id==discrete_inputs_map[discrete_input_read].node_id &&
                    discrete_inputs_map[i].address == discrete_inputs_map[discrete_input_read].address )
                  {
                  break;
                  }
               }
            if ( i == (BYTE)MX_DI )
               {
               return;
               }
            discrete_input_read++ ;
            da_put_BIT(&discrete_inputs_map[i],value);
         }
         break ;

      case MODBUS_READ_INPUTREGISTERS :
         {
            /******************************************************************/
            /*      READ INPUT REGISTERS                                      */
            /******************************************************************/
            UINT16 value   =  (UINT16)(((UINT16)(UART_RX_buf[3]) << 8)|((UINT16)(UART_RX_buf[4]))); ;

            for ( i = 0 ; i < (BYTE)MX_REG ; i++ )
               {
               if ( register_map[i].node_id==register_map[register_read].node_id &&
                    register_map[i].address == register_map[register_read].address )
                  {
                  break;
                  }
               }
            if ( i == (BYTE)MX_DI )
               {
               return;
               }
            register_read++ ;
            da_put_UINT16(&register_map[i],value);
         }
         break ;

      case MODBUS_WRITE_COIL :
         {
            /******************************************************************/
            /*      WRITE COILS                                               */
            /******************************************************************/
            UINT16 mb_address = (UINT16)( (UINT16)( (UART_RX_buf[2]<<8) | (UINT16)(UART_RX_buf[3]) ) + 1 ) ;

            for ( i = 0 ; i < (BYTE)MX_COILS ; i ++ )
               {
               if ( coil_map[i].node_id == node_id &&
                    coil_map[i].address == mb_address )
                  {
                  break;
                  }
               }
            coil_write++ ;
         }

         break ;

      case MODBUS_WRITE_REGISTER :
         {
            /******************************************************************/
            /*      WRITE REGISTER                                             */
            /******************************************************************/
            UINT16 mb_address = (UINT16)( (UINT16)( (UART_RX_buf[2]<<8) | (UINT16)(UART_RX_buf[3]) ) + 1 ) ;

            for ( i = 0 ; i < (BYTE)MX_REG ; i ++ )
               {
               if ( register_map[i].node_id == node_id &&
                    register_map[i].address == mb_address )
                  {
                  break;
                  }
               }
            register_write++ ;
         }
         break ;

      case EX_MODBUS_READ_COILS:
      case EX_MODBUS_READ_DISCRETEINPUTS:
      case EX_MODBUS_READ_INPUTREGISTERS:
      case EX_MODBUS_WRITE_COIL:
      case EX_MODBUS_WRITE_REGISTER:
         break;
      default:
         break;
      }
}

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

BYTE modbusPacketResponseComplete (VOID)
{
   UINT16  crc ;
   BYTE    target=0 ;

   get_PICUART_data () ;

   /******************************************************************/
   /*      LESS THAN FOUR BYTES RECEIVED CMPLT_HOPE                  */
   /******************************************************************/
   if ( UART_rcv_count < (BYTE)4 )
      {
      return( CMPLT_HOPE ) ;
      }

   /******************************************************************/
   /*      IS THIS THE REPLY TO THE SENT MESSAGE                     */
   /******************************************************************/
   if ( UART_RX_buf[0] != current_node_ref )
      {
      return CMPLT_NO_HOPE;
      }

   /******************************************************************/
   /*      CHECK FOR EXCEPTION CODE                                  */
   /******************************************************************/
   if ( UART_RX_buf[1] & 0x80 )
      {
      target = 3 ;
      }
   else
      {
      switch ( UART_RX_buf[1] )
         {
         case MODBUS_READ_COILS            :
         case MODBUS_READ_DISCRETEINPUTS   :
         case MODBUS_READ_INPUTREGISTERS   :
            target = (BYTE)(UART_RX_buf[2] + 3) ;
            break ;
         case MODBUS_WRITE_COIL            :
         case MODBUS_WRITE_REGISTER        :
            target = 6 ;
            break ;
         default:
            break;
         }
      }

   /******************************************************************/
   /*      'target' IS THE LENGTH OF THE MESSAGE WITHOUT CHECKSUM    */
   /******************************************************************/
   if ( UART_rcv_count < ( target + 2 ) )
      {
      return CMPLT_HOPE ;
      }
   else
      {
      crc = modrtuChecksum (UART_RX_buf, (BYTE)(UART_rcv_count - 2)) ;
      if ( UART_RX_buf[UART_rcv_count-2] == ((BYTE)(crc >> 8) & 0xff) && ((BYTE)UART_RX_buf[UART_rcv_count-1] == (BYTE)(crc & 0xFF)) )
         {
         return CMPLT_COMPLETE ;
         }
      else
         {
         return CMPLT_NO_HOPE;
         }
      }
}
/*============================================================================*/