master

分支 (1)

管理

管理

master

tcp-stack
/
modbusV2
/
modbus_slave.c

#include "modbus_slave.h"
#include "CRC.h"

#define BIG_ENDIAN     (0)
#define LITTLE_ENDIAN  (1)

static int mode  = 0;


/*********************************************************************************************************
 *Modbus功能码01处理程序  读输出开关量
 *收到：设备地址+功能码+起始地址（高位）+起始地址（低位）+寄存器数（高位）+寄存器数（低位）+CRC(低位)+CRC(高位)
 *发送：设备地址+功能码+ 数据字节数 + 数据 + CRC(低位)+CRC(高位)
 *异常：设备地址+功能码|0x80 + 异常码 + CRC(低位)+CRC(高位)
**********************************************************************************************************/
static void Modbus_01_Solve(MODBUS_DC_TCM *pDc,ITEM_T *itemMap,uint16_t itemNum)
{
  uint16_t calCRC;
  uint16_t RegNum;
  uint16_t ByteNum;
  uint16_t i,k;
  uint16_t startRegAddr;

  startRegAddr = (((uint16_t)pDc->RX_BUFF[2])<<8) | pDc->RX_BUFF[3];//获取寄存器起始地址
  RegNum = (((uint16_t)pDc->RX_BUFF[4])<<8) | pDc->RX_BUFF[5];//获取寄存器数量 等价于获取bit位数

  pDc->TX_BUFF[0] = pDc->RX_BUFF[0];
  pDc->TX_BUFF[1] = pDc->RX_BUFF[1];
  ByteNum = RegNum/8;//字节数
  if(RegNum%8) ByteNum += 1;//如果位数还有余数，则字节数+1
  pDc->TX_BUFF[2] = ByteNum;//返回要读取的字节数


  for(k=0; k<itemNum; k++)
  {
    if(startRegAddr >= itemMap[k].start_addr && startRegAddr < itemMap[k].end_addr)
    {
      break;
    }
  }

  for(i=0; i<RegNum;)
  {
    pDc->TX_BUFF[3+i/8] = itemMap[k].data[(startRegAddr-itemMap[k].start_addr)/8];

    if(i+8 > RegNum)
    {
      pDc->TX_BUFF[3+i/8] &= (0xff >> (RegNum - i) );
    }


    if((startRegAddr-itemMap[k].start_addr)/8 + 1 >= itemMap[k].size)
    {
      k++;
    }
    startRegAddr = startRegAddr+8;
    i = i+8;
  }

  calCRC=CRC_Compute(pDc->TX_BUFF,ByteNum+3);
  pDc->TX_BUFF[ByteNum+3] = calCRC&0xFF;
  pDc->TX_BUFF[ByteNum+4] = (calCRC>>8)&0xFF;
  pDc->SendData(pDc->TX_BUFF,ByteNum+5);
}

/*********************************************************************************************************
 *Modbus功能码02处理程序  读输入开关量
 *收到：设备地址+功能码 +起始地址（高位）+起始地址（低位）+寄存器数（高位）+寄存器数（低位）+CRC(低位)+CRC(高位)
 *发送：设备地址+功能码 + 数据字节数 + 数据 + CRC(低位)+CRC(高位)
 *异常：设备地址+功能码|0x80 + 异常码 + CRC(低位)+CRC(高位)
**********************************************************************************************************/
static void Modbus_02_Solve(MODBUS_DC_TCM *pDc,ITEM_T *itemMap,uint16_t itemNum)
{
  Modbus_01_Solve(pDc,itemMap,itemNum);
}

/*********************************************************************************************************
 *Modbus功能码03发送程序  读保持寄存器
 *收到：设备地址+功能码+起始地址（高位）+起始地址（低位）+寄存器数（高位）+寄存器数（低位）+CRC(低位)+CRC(高位)
 *发送：设备地址+功能码 + 数据字节数N + N个字节的数据 + CRC(低位)+CRC(高位)
 *异常：设备地址+功能码|0x80 + 异常码 + CRC(低位)+CRC(高位)
**********************************************************************************************************/
static void Modbus_03_Solve(MODBUS_DC_TCM *pDc,ITEM_T *itemMap,uint16_t itemNum)
{
  uint16_t calCRC;
  uint16_t RegNum;
  uint8_t i,k;
  uint16_t startRegAddr;

  startRegAddr = (((uint16_t)pDc->RX_BUFF[2])<<8) | pDc->RX_BUFF[3];//获取寄存器起始地址
  RegNum= (((uint16_t)pDc->RX_BUFF[4])<<8) | pDc->RX_BUFF[5];//获取寄存器数量

  for(k=0; k<itemNum; k++)
  {
    if(startRegAddr >= itemMap[k].start_addr && startRegAddr < itemMap[k].end_addr)
    {
      break;
    }
  }

  pDc->TX_BUFF[0]=pDc->RX_BUFF[0];
  pDc->TX_BUFF[1]=pDc->RX_BUFF[1];
  pDc->TX_BUFF[2]=RegNum*2; //寄存器数是以字为单位，返回的是字节数 所以*2


  for(i=0; i<RegNum; i++)
  {
    if(mode == LITTLE_ENDIAN && itemMap[k].auto_convert == 1)
    {
       pDc->TX_BUFF[3+i*2] = itemMap[k].data[itemMap[k].size - 1 - (startRegAddr-itemMap[k].start_addr)*2];

      if((startRegAddr-itemMap[k].start_addr)*2+1 >= itemMap[k].size)
      {
        k++;
        startRegAddr++;
        continue;
      }

      pDc->TX_BUFF[4+i*2] = itemMap[k].data[itemMap[k].size - 1 - ((startRegAddr-itemMap[k].start_addr)*2+1)];
    }
    else
    {
      pDc->TX_BUFF[3+i*2] = itemMap[k].data[(startRegAddr-itemMap[k].start_addr)*2];

      if((startRegAddr-itemMap[k].start_addr)*2+1 >= itemMap[k].size)
      {
        k++;
        startRegAddr++;
        continue;
      }

      pDc->TX_BUFF[4+i*2] = itemMap[k].data[(startRegAddr-itemMap[k].start_addr)*2+1];
    }


    if((startRegAddr-itemMap[k].start_addr)*2+2 >= itemMap[k].size)
    {
      k++;
    }
    startRegAddr++;
  }

  calCRC = CRC_Compute(pDc->TX_BUFF,RegNum*2+3);
  pDc->TX_BUFF[RegNum*2+3] = calCRC&0xFF;
  pDc->TX_BUFF[RegNum*2+4] = (calCRC>>8)&0xFF;
  pDc->SendData(pDc->TX_BUFF,RegNum*2+5);
}

/*********************************************************************************************************
 *Modbus功能码04发送程序  读输入寄存器
 *收到：设备地址+功能码+起始地址（高位）+起始地址（低位）+寄存器数（高位）+寄存器数（低位）+CRC(低位)+CRC(高位)
 *发送：设备地址+功能码 + 数据字节数N + N个字节的数据 + CRC(低位)+CRC(高位)
 *异常：设备地址+功能码|0x80 + 异常码 + CRC(低位)+CRC(高位)
**********************************************************************************************************/
static void Modbus_04_Solve(MODBUS_DC_TCM *pDc,ITEM_T *itemMap,uint16_t itemNum)
{
  Modbus_03_Solve(pDc,itemMap,itemNum);
}


/*********************************************************************************************************
 *Modbus功能码05发送程序 写单个输出开关量
 *收到：设备地址+功能码+起始地址（高位）+起始地址（低位）+变更数据（高位）+变更数据（低位）+CRC(低位)+CRC(高位)
 *发送：设备地址+功能码+起始地址（高位）+起始地址（低位）+变更数据（高位）+变更数据（低位）+CRC(低位)+CRC(高位)
 *异常：设备地址+功能码|0x80 + 异常码 + CRC(低位)+CRC(高位)
**********************************************************************************************************/
static void Modbus_05_Solve(MODBUS_DC_TCM *pDc,ITEM_T *itemMap,uint16_t itemNum)
{
  int k;
  uint16_t calCRC;
  uint16_t startRegAddr;

  startRegAddr = (((uint16_t)pDc->RX_BUFF[2])<<8) | pDc->RX_BUFF[3];//获取寄存器起始地址

  for(k=0; k<itemNum; k++)
  {
    if(startRegAddr >= itemMap[k].start_addr && startRegAddr < itemMap[k].end_addr)
    {
      break;
    }
  }

  if((pDc->RX_BUFF[4]==0xFF)&&(pDc->RX_BUFF[5]==0x00))
  {
    itemMap[k].data[(startRegAddr-itemMap[k].start_addr)/8] |= (0x01 << ((startRegAddr-itemMap[k].start_addr)%8));
  }
  else if((pDc->RX_BUFF[4]==0x00)&&(pDc->RX_BUFF[5]==0x00))
  {
    itemMap[k].data[(startRegAddr-itemMap[k].start_addr)/8] &= (~(0x01 << ((startRegAddr-itemMap[k].start_addr)%8)));
  }
  else//变更数据不正确 因为输出值必须为0x0000 或者 0xff00
  {
      pDc->TX_BUFF[0] = pDc->RX_BUFF[0];
      pDc->TX_BUFF[1] = pDc->RX_BUFF[1] | 0x80;
      pDc->TX_BUFF[2] = 0x03; //异常码
      calCRC=CRC_Compute(pDc->TX_BUFF,3);
      pDc->TX_BUFF[3] = calCRC&0xFF;
      pDc->TX_BUFF[4] = (calCRC>>8)&0xFF;
      pDc->SendData(pDc->TX_BUFF,5);
      return;
  }

  pDc->TX_BUFF[0] = pDc->RX_BUFF[0];
  pDc->TX_BUFF[1] = pDc->RX_BUFF[1];
  pDc->TX_BUFF[2] = pDc->RX_BUFF[2];
  pDc->TX_BUFF[3] = pDc->RX_BUFF[3];
  pDc->TX_BUFF[4] = pDc->RX_BUFF[4];
  pDc->TX_BUFF[5] = pDc->RX_BUFF[5];

  calCRC=CRC_Compute(pDc->TX_BUFF,6);
  pDc->TX_BUFF[6] = calCRC&0xFF;
  pDc->TX_BUFF[7] = (calCRC>>8)&0xFF;
  pDc->SendData(pDc->TX_BUFF,8);
}


/*********************************************************************************************************
 *Modbus功能码06发送程序 写单个保持寄存器
 *收到：设备地址+功能码+起始地址（高位）+起始地址（低位）+变更数据（高位）+变更数据（低位）+CRC(低位)+CRC(高位)
 *发送：设备地址+功能码+起始地址（高位）+起始地址（低位）+变更数据（高位）+变更数据（低位）+CRC(低位)+CRC(高位)
 *异常：设备地址+功能码|0x80 + 异常码 + CRC(低位)+CRC(高位)
**********************************************************************************************************/
static void Modbus_06_Solve(MODBUS_DC_TCM *pDc,ITEM_T *itemMap,uint16_t itemNum)
{
  int k;
  uint16_t calCRC;
  uint16_t startRegAddr;

  startRegAddr = (((uint16_t)pDc->RX_BUFF[2])<<8)|pDc->RX_BUFF[3];//获取寄存器起始地址

  for(k=0; k<itemNum; k++)
  {
    if(startRegAddr >= itemMap[k].start_addr && startRegAddr < itemMap[k].end_addr)
    {
      break;
    }
  }

  if(mode == LITTLE_ENDIAN && itemMap[k].auto_convert == 1)
  {
    itemMap[k].data[(startRegAddr-itemMap[k].start_addr)*2] = pDc->RX_BUFF[5];

    if((startRegAddr-itemMap[k].start_addr)*2+1 < itemMap[k].size)
    {
      itemMap[k].data[(startRegAddr-itemMap[k].start_addr)*2+1] = pDc->RX_BUFF[4];
    }
  }
  else
  {
    itemMap[k].data[(startRegAddr-itemMap[k].start_addr)*2] = pDc->RX_BUFF[4];

    if((startRegAddr-itemMap[k].start_addr)*2+1 < itemMap[k].size)
    {
      itemMap[k].data[(startRegAddr-itemMap[k].start_addr)*2+1] = pDc->RX_BUFF[5];
    }
  }

  pDc->TX_BUFF[0] = pDc->RX_BUFF[0];
  pDc->TX_BUFF[1] = pDc->RX_BUFF[1];
  pDc->TX_BUFF[2] = pDc->RX_BUFF[2];
  pDc->TX_BUFF[3] = pDc->RX_BUFF[3];
  pDc->TX_BUFF[4] = pDc->RX_BUFF[4];
  pDc->TX_BUFF[5] = pDc->RX_BUFF[5];

  calCRC=CRC_Compute(pDc->TX_BUFF,6);
  pDc->TX_BUFF[6] = calCRC&0xFF;
  pDc->TX_BUFF[7] = (calCRC>>8)&0xFF;
  pDc->SendData(pDc->TX_BUFF,8);

}


/*********************************************************************************************************
 *Modbus功能码15发送程序  写多个输出开关量
 *收到：设备地址+功能码+起始地址（高位）+起始地址（低位）+寄存器数（高位）+寄存器数（低位）
 *   +字节数N + N个变更数据 + CRC(低位)+CRC(高位)
 *发送：设备地址+功能码+起始地址（高位）+起始地址（低位）+寄存器数（高位）+寄存器数（低位）
 *异常：设备地址+功能码|0x80 + 异常码 + CRC(低位)+CRC(高位)
**********************************************************************************************************/
static void Modbus_15_Solve(MODBUS_DC_TCM *pDc,ITEM_T *itemMap,uint16_t itemNum)
{
  uint16_t calCRC;
  uint16_t RegNum;
  uint16_t startRegAddr;
  uint16_t i,k;

  startRegAddr = (((uint16_t)pDc->RX_BUFF[2])<<8)|pDc->RX_BUFF[3];//获取寄存器起始地址
  RegNum = (((uint16_t)pDc->RX_BUFF[4])<<8)|pDc->RX_BUFF[5];//获取寄存器数量

  for(k=0; k<itemNum; k++)
  {
    if(startRegAddr >= itemMap[k].start_addr && startRegAddr < itemMap[k].end_addr)
    {
      break;
    }
  }

  for(i=0; i<RegNum;)
  {
    if(i+8 > RegNum)
    {
      pDc->RX_BUFF[7+i/8] |= ((itemMap[k].data[(startRegAddr-itemMap[k].start_addr)/8] >> (RegNum - i) ) << (RegNum - i));
    }

    itemMap[k].data[(startRegAddr-itemMap[k].start_addr)/8] = pDc->RX_BUFF[7+i/8];

    if((startRegAddr-itemMap[k].start_addr)/8 + 1 >= itemMap[k].size)
    {
      k++;
    }
    startRegAddr = startRegAddr+8;
    i = i+8;
  }

  pDc->TX_BUFF[0] = pDc->RX_BUFF[0];
  pDc->TX_BUFF[1] = pDc->RX_BUFF[1];
  pDc->TX_BUFF[2] = pDc->RX_BUFF[2];
  pDc->TX_BUFF[3] = pDc->RX_BUFF[3];
  pDc->TX_BUFF[4] = pDc->RX_BUFF[4];
  pDc->TX_BUFF[5] = pDc->RX_BUFF[5];
  calCRC=CRC_Compute(pDc->TX_BUFF,6);
  pDc->TX_BUFF[6] = calCRC&0xFF;
  pDc->TX_BUFF[7] = (calCRC>>8)&0xFF;
  pDc->SendData(pDc->TX_BUFF,8);
}


/*********************************************************************************************************
 *Modbus功能码16发送程序  写多个保持寄存器
 *收到：设备地址+功能码+起始地址（高位）+起始地址（低位）+寄存器数（高位）+寄存器数（低位）
 *   +字节数N + N/2个字变更数据（先高位再低位） + CRC(低位)+CRC(高位)
 *发送：设备地址+功能码+起始地址（高位）+起始地址（低位）+寄存器数（高位）+寄存器数（低位）
 *异常：设备地址+功能码|0x80 + 异常码 + CRC(低位)+CRC(高位)
**********************************************************************************************************/
static void Modbus_16_Solve(MODBUS_DC_TCM *pDc,ITEM_T *itemMap,uint16_t itemNum)
{
  uint16_t calCRC;
  uint8_t i,k;
  uint16_t RegNum;
  uint16_t startRegAddr;

  startRegAddr = (((uint16_t)pDc->RX_BUFF[2])<<8) | pDc->RX_BUFF[3];//获取寄存器起始地址
  RegNum = (((uint16_t)pDc->RX_BUFF[4])<<8) | pDc->RX_BUFF[5];      //获取寄存器数量

  for(k=0; k<itemNum; k++)
  {
    if(startRegAddr >= itemMap[k].start_addr && startRegAddr < itemMap[k].end_addr)
    {
      break;
    }
  }

  for(i=0; i<RegNum; i++)
  {
    if(mode == LITTLE_ENDIAN && itemMap[k].auto_convert == 1)
    {
      itemMap[k].data[itemMap[k].size - 1 - (startRegAddr-itemMap[k].start_addr)*2] = pDc->RX_BUFF[7+i*2];

      if((startRegAddr-itemMap[k].start_addr)*2+1 >= itemMap[k].size)
      {
        k++;
        startRegAddr++;
        continue;
      }

      itemMap[k].data[itemMap[k].size - 1 - ((startRegAddr-itemMap[k].start_addr)*2+1)] = pDc->RX_BUFF[8+i*2];;
    }
    else
    {
      itemMap[k].data[(startRegAddr-itemMap[k].start_addr)*2] = pDc->RX_BUFF[7+i*2];

      if((startRegAddr-itemMap[k].start_addr)*2+1 >= itemMap[k].size)
      {
        k++;
        startRegAddr++;
        continue;
      }

      itemMap[k].data[(startRegAddr-itemMap[k].start_addr)*2+1] = pDc->RX_BUFF[8+i*2];
    }

    if((startRegAddr-itemMap[k].start_addr)*2+2 >= itemMap[k].size)
    {
      k++;
    }
    startRegAddr++;
  }

  pDc->TX_BUFF[0] = pDc->RX_BUFF[0];
  pDc->TX_BUFF[1] = pDc->RX_BUFF[1];
  pDc->TX_BUFF[2] = pDc->RX_BUFF[2];
  pDc->TX_BUFF[3] = pDc->RX_BUFF[3];
  pDc->TX_BUFF[4] = pDc->RX_BUFF[4];
  pDc->TX_BUFF[5] = pDc->RX_BUFF[5];

  calCRC=CRC_Compute(pDc->TX_BUFF,6);
  pDc->TX_BUFF[6] = calCRC&0xFF;
  pDc->TX_BUFF[7] = (calCRC>>8)&0xFF;
  pDc->SendData(pDc->TX_BUFF,8);
  return;
}

static void  Modbus_Parse_Hand(MODBUS_DC_TCM *pDc)
{
  uint16_t calCRC;
  uint8_t j;
  uint16_t RegNum;
  uint16_t startRegAddr;

  startRegAddr = (((uint16_t)pDc->RX_BUFF[2])<<8) | pDc->RX_BUFF[3];//获取寄存器起始地址
  RegNum = (((uint16_t)pDc->RX_BUFF[4])<<8) | pDc->RX_BUFF[5];      //获取寄存器数量

  switch(pDc->RX_BUFF[1])//根据不同的功能码进行处理
  {
    case 05://写单个输出开关量
      RegNum = 1;
    case 01://读输出开关量
    case 02://读输入开关量
    case 15://写多个输出开关量
      for(j=0; j<pDc->status_map_num; j++)
      {
        if(pDc->status_map_tab[j].fun_code != pDc->RX_BUFF[1])
        {
          continue;
        }

        if(startRegAddr < pDc->status_map_tab[j].start_addr)
        {
          continue;
        }

        if((startRegAddr+RegNum) > pDc->status_map_tab[j].end_addr)
        {
          pDc->TX_BUFF[0] = pDc->RX_BUFF[0];
          pDc->TX_BUFF[1] = pDc->RX_BUFF[1] | 0x80;
          pDc->TX_BUFF[2] = 0x02; //异常码
          calCRC=CRC_Compute(pDc->TX_BUFF,3);
          pDc->TX_BUFF[3] = calCRC&0xFF;
          pDc->TX_BUFF[4] = (calCRC>>8)&0xFF;
          pDc->SendData(pDc->TX_BUFF,5);
          return;
        }
        break;
      }
      if(j == pDc->status_map_num)
      {
        return;
      }
      break;
    case 06://写单个保持寄存器
      RegNum = 1;
    case 03://读保持寄存器
    case 04://读输入寄存器
    case 16://写多个保持寄存器
      for(j=0; j<pDc->analog_map_num; j++)
      {
        if(pDc->analog_map_tab[j].fun_code != pDc->RX_BUFF[1])
        {
          continue;
        }

        if(startRegAddr < pDc->analog_map_tab[j].start_addr)
        {
          continue;
        }

        if((startRegAddr+RegNum) > pDc->analog_map_tab[j].end_addr)
        {
          pDc->TX_BUFF[0] = pDc->RX_BUFF[0];
          pDc->TX_BUFF[1] = pDc->RX_BUFF[1] | 0x80;
          pDc->TX_BUFF[2] = 0x02; //异常码
          calCRC=CRC_Compute(pDc->TX_BUFF,3);
          pDc->TX_BUFF[3] = calCRC&0xFF;
          pDc->TX_BUFF[4] = (calCRC>>8)&0xFF;
          pDc->SendData(pDc->TX_BUFF,5);
          return;
        }
        break;
      }
      if(j == pDc->analog_map_num)
      {
        return;
      }
      break;
    default://功能码错误
      pDc->TX_BUFF[0] = pDc->RX_BUFF[0];
      pDc->TX_BUFF[1] = pDc->RX_BUFF[1] | 0x80;
      pDc->TX_BUFF[2] = 0x01; //异常码
      calCRC=CRC_Compute(pDc->TX_BUFF,3);
      pDc->TX_BUFF[3] = calCRC & 0xFF;
      pDc->TX_BUFF[4] = (calCRC>>8) & 0xFF;
      pDc->SendData(pDc->TX_BUFF,5);
      break;
  }


  switch(pDc->RX_BUFF[1])//根据不同的功能码进行处理
  {
    case 01://读输出开关量
    {
        Modbus_01_Solve(pDc,pDc->status_map_tab[j].itemMap,pDc->status_map_tab[j].itemNum);
        break;
    }
    case 02://读输入开关量
    {
        Modbus_02_Solve(pDc,pDc->status_map_tab[j].itemMap,pDc->status_map_tab[j].itemNum);
        break;
    }
    case 03://读保持寄存器
    {
        Modbus_03_Solve(pDc,pDc->analog_map_tab[j].itemMap,pDc->analog_map_tab[j].itemNum);
        break;
    }
    case 04://读输入寄存器
    {
        Modbus_04_Solve(pDc,pDc->analog_map_tab[j].itemMap,pDc->analog_map_tab[j].itemNum);
        break;
    }
    case 05://写单个输出开关量
    {
        Modbus_05_Solve(pDc,pDc->status_map_tab[j].itemMap,pDc->status_map_tab[j].itemNum);
        break;
    }
    case 06: //写单个保持寄存器
    {
        Modbus_06_Solve(pDc,pDc->analog_map_tab[j].itemMap,pDc->analog_map_tab[j].itemNum);
        break;
    }
    case 15: //写多个输出开关量
    {
        Modbus_15_Solve(pDc,pDc->status_map_tab[j].itemMap,pDc->status_map_tab[j].itemNum);
        break;
    }
    case 16: //写多个保持寄存器
    {
        Modbus_16_Solve(pDc,pDc->analog_map_tab[j].itemMap,pDc->analog_map_tab[j].itemNum);
        break;
    }
  }
}

void Modbus_RTU_Service(MODBUS_DC_TCM *pDc)
{
    uint16_t calCRC;
    uint16_t recCRC;

    if(pDc->RX_CNT > MAX_FRAME_LENGTH || pDc->RX_CNT < MIN_FRAME_LENGTH)
    {
        //打印帧格式错误
    }
    else if(pDc->RX_BUFF[0] == pDc->Modbus_Addr)//地址正确
    {
        calCRC = CRC_Compute(pDc->RX_BUFF,pDc->RX_CNT-2);//计算所接收数据的CRC
        recCRC = pDc->RX_BUFF[pDc->RX_CNT-2] | (((uint16_t)pDc->RX_BUFF[pDc->RX_CNT-1])<<8);//接收到的CRC(低字节在前，高字节在后)
        if(calCRC == recCRC)//CRC校验正确
        {
          Modbus_Parse_Hand(pDc);
        }
        else
        {
          //回复校验码错误
        }
    }

    pDc->RX_CNT = 0;//接收计数器清零
}


void Modbus_TCP_Service(MODBUS_DC_TCM *pDc)
{
  uint8_t Len;

  if(pDc->RX_CNT < 6)
  {
    pDc->RX_CNT = 0;
    return;
  }

	if(pDc->RX_CNT < (pDc->RX_BUFF[5] + 6))
  {
    pDc->RX_CNT = 0;
    return;
  }

  Len = pDc->RX_BUFF[5];
  memcpy(pDc->RX_BUFF,&pDc->RX_BUFF[6],Len);

  Modbus_Parse_Hand(pDc);

  pDc->RX_CNT = 0;
}

/*************************************************************对外接口****************************************************************/

void Set_Modbus_Status_Map(MODBUS_DC_TCM *pDc,uint16_t start_addr,uint8_t  fun_code,ITEM_T *status_map,unsigned int num)
{
  int i = 0;
  int total_size = 0;

  pDc->status_map_tab[pDc->status_map_num].itemMap = status_map;
  pDc->status_map_tab[pDc->status_map_num].start_addr = start_addr;
  pDc->status_map_tab[pDc->status_map_num].fun_code = fun_code;
  pDc->status_map_tab[pDc->status_map_num].itemNum = num;

  for(i=0;i<num;i++)
  {
    status_map[i].start_addr = start_addr + total_size*8;
    //printf("startaddr:%x\r\n",status_map[i].start_addr);
    total_size += status_map[i].size;
    status_map[i].end_addr = start_addr + total_size*8;
    //printf("endaddr:%x\r\n",status_map[i].end_addr);
  }

  pDc->status_map_tab[pDc->status_map_num].end_addr = start_addr + total_size*8;
  pDc->status_map_num++;

}

void Set_Modbus_Analog_Map(MODBUS_DC_TCM *pDc,uint16_t start_addr,uint8_t  fun_code,ITEM_T *analog_map,unsigned int num)
{
  int i = 0;
  int total_size = 0;

  pDc->analog_map_tab[pDc->analog_map_num].itemMap = analog_map;
  pDc->analog_map_tab[pDc->analog_map_num].start_addr = start_addr;
  pDc->analog_map_tab[pDc->analog_map_num].fun_code = fun_code;
  pDc->analog_map_tab[pDc->analog_map_num].itemNum = num;

  for(i=0;i<num;i++)
  {
    analog_map[i].start_addr = start_addr + total_size/2;
    //printf("startaddr:%x\r\n",analog_map[i].start_addr);

    total_size += analog_map[i].size;

    if(total_size%2)
    {
      total_size++;
    }
    analog_map[i].end_addr = start_addr + total_size/2;
    //printf("endaddr:%x\r\n",analog_map[i].end_addr);
  }

  pDc->analog_map_tab[pDc->analog_map_num].end_addr = start_addr + total_size/2;

  pDc->analog_map_num++;
}


/******************************
 *设置回调函数
 *返回0 设置失败 返回1 设置成功
******************************/
int Set_Modbus_Cb(MODBUS_DC_TCM *pDc,uint8_t Fun_Code, void (*callback)(uint16_t startRegAddr))
{
  if(!callback)
  {
    return 0;
  }
  switch(Fun_Code)
  {

  }
  return 1;
}


/*modbus一切服务从这里开始*/
int Create_Modbus_Service(MODBUS_DC_TCM *pDc,uint8_t addr,int (*SendData)(uint8_t *,int))
{
    int data = 0x12345678;
    char *ch = (char *)&data;

    memset(pDc,0,sizeof(MODBUS_DC_TCM));

    pDc->Modbus_Addr = addr;//设置modbus本机地址
    pDc->SendData = SendData;

    if(*ch == 0x78)
    {
      mode = LITTLE_ENDIAN;
    }
    else
    {
      mode = BIG_ENDIAN;
    }
    return 1;
}