#include "StdAfx.h"
#include <WinDef.h>
#include <WinBase.h>
#include "So7_TCPIP_Server.h"

const int WSA_MAJOR_VERSION = 1;
const int WSA_MINOR_VERSION = 1;
#define WSA_VERSION MAKEWORD(WSA_MAJOR_VERSION, WSA_MINOR_VERSION)
#define SOCKADDR_LEN sizeof(SOCKADDR_IN)

const BYTE CommHeader[]={0x46,0x49,0x4E,0x53};
const BYTE HandShaking[]={0X46,0X49,0X4E,0X53,0X00,0X00,0X00,0X10,0X00,0X00,0X00,0X01,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X03,0X00,0X00,0X00,0X05};
const BYTE DRW_SData[]={0X46,0X49,0X4E,0X53,0X00,0X00,0X00,0X16,0X00,0X00,0X00,0X02,0X00,0X00,0X00,0X00,0XC0,0X00,0X02,0X00,0X03,0X00,0X00,0X05,0X00,0XFF,0X01,0X01,0X00,0X00};

const int  DRW_SDataIndexDataSize1=6;
const int  DRW_SDataIndexDataSize2=7;
const int  DRW_SDataHeadDataSize=8;
const int  DRW_SDataIndexData=30;

const int  DRW_RDataIndexDA1=20;
const int  DRW_RDataIndexSA1=23;
const int  DRW_RDataIndexCMD1=26;
const int  DRW_RDataIndexCMD2=27;
const int  DRW_RDataIndexAddr1=29;
const int  DRW_RDataIndexAddr2=30;
const int  DRW_RDataIndexCh1=32;
const int  DRW_RDataIndexCh2=33;
const int  DRW_RDataIndexData=34;
const int  DRW_RDataCCLen=0x1A;

const int  DRW_RSDataIndexBufSize1=6;
const int  DRW_RSDataIndexBufSize2=7;




struct_so7_tcpip_buff  CSo7_TCPIP_Server::m_TCPIPBuf[lChannelSize];
s_tcpip_state  CSo7_TCPIP_Server::m_TCPIPServerState;

HANDLE CSo7_TCPIP_Server::m_Thread_Id=NULL;
HANDLE CSo7_TCPIP_Server::m_Thread_Mutex=NULL;
HANDLE CSo7_TCPIP_Server::m_MultiThread_Mutex=NULL;
int    CSo7_TCPIP_Server::m_Thread_State=TCPIP_THREAD_PAUSED;
WSAEVENT CSo7_TCPIP_Server::m_SocketEvents[WSA_MAXIMUM_WAIT_EVENTS] = { NULL };
SOCKET CSo7_TCPIP_Server::m_ClientSocket[WSA_MAXIMUM_WAIT_EVENTS] = { NULL };
int CSo7_TCPIP_Server::m_nClients = 0;

//================================================================
CSo7_TCPIP_Server::CSo7_TCPIP_Server()
{
  m_hMsgWnd=NULL;
  m_ServerStarted=FALSE;
  m_Socket=INVALID_SOCKET;
  m_SreverIPAddress.S_un.S_un_b.s_b1=127;
  m_SreverIPAddress.S_un.S_un_b.s_b2=0;
  m_SreverIPAddress.S_un.S_un_b.s_b3=0;
  m_SreverIPAddress.S_un.S_un_b.s_b4=1;
  m_iServerPortNumber=static_cast<u_short>(0);  
  for (int i=0;i<MAX_SOCKET;i++)
  {
    m_ClientSocket[i]=INVALID_SOCKET;
    m_SocketEvents[i]=nullptr;
  }
  m_nClients=0;
  for (int i=0;i<lChannelSize;i++)
  {
    m_TCPIPBuf[i]._size             = 0;
    m_TCPIPBuf[i]._CompletedSize    = 0;
    m_TCPIPBuf[i]._save_send_cmd    = 99;
    m_TCPIPBuf[i]._buffer           = (char *)malloc(sizeof(char)*TCPIP_MAX_BUFF_SIZE);
    m_TCPIPBuf[i]._hProtoPending    = false;
    m_TCPIPBuf[i]._event            = NULL;
  };
  DM5000= (short *)malloc(sizeof(short)*MAX_DM_PAGE_NUMBER);
  DM8000= (short *)malloc(sizeof(short)*MAX_DM_PAGE_NUMBER);
  DM10000= (short *)malloc(sizeof(short)*MAX_DM_PAGE_NUMBER);
  DM200= (short *)malloc(sizeof(short)*200);

  memset(DM5000,0,sizeof(short)*MAX_DM_PAGE_NUMBER);
  memset(DM8000,0,sizeof(short)*MAX_DM_PAGE_NUMBER);
  memset(DM10000,0,sizeof(short)*MAX_DM_PAGE_NUMBER);
  memset(DM200,0,sizeof(short)*200);
  m_TCPIPMsg.Init();
}


//================================================================
CSo7_TCPIP_Server::~CSo7_TCPIP_Server()
{
  StopServer();
  for (int i=0;i<lChannelSize;i++)
  {
    free(m_TCPIPBuf[i]._buffer);
    m_TCPIPBuf[i]._buffer=NULL;
  }
  free(DM5000);
  DM5000=NULL;
  free(DM8000);
  DM8000=NULL;
  free(DM10000);
  DM10000=NULL;
  free(DM200);
  DM200=NULL;
}
//================================================================
int CSo7_TCPIP_Server::Init_Winsock()
{
  int nRet;
  static int first = TRUE;
  if (first)
  {
    WSADATA stWSAData;    /* WinSock DLL Info */
    nRet = WSAStartup(WSA_VERSION, &stWSAData);
    if (nRet)
    {
      return FALSE;
    }
    first = FALSE;
  }
  return TRUE;
}
//================================================================
BOOL CSo7_TCPIP_Server::StartServer(HWND _hWnd,short _nPort)
{
  if (m_ServerStarted)
  {
    return FALSE;
  }
  int retVal=Init_Winsock();
  retVal=Init_Winsock();
  if(!retVal)
  {
    return FALSE;
  }
  m_iServerPortNumber=_nPort;
  GetHostIPAddr(m_SreverIPAddress);
  m_hMsgWnd=_hWnd;
  if (CreateAndListen())
  {
    m_ServerStarted=TRUE;
  }
  else
  {
    return FALSE;
  }
  return TRUE;
}
//================================================================
BOOL CSo7_TCPIP_Server::StopServer()
{
  if(m_Socket == INVALID_SOCKET)
  {
    return FALSE;
  }
  if (m_ServerStarted)
  {
    Exit_Thread();
    CloseAllSocket();
    closesocket(m_Socket);
    m_Socket = INVALID_SOCKET;
    m_ServerStarted=FALSE;

    m_hMsgWnd=NULL;
    m_ServerStarted=FALSE;
    m_Socket=INVALID_SOCKET;
    m_SreverIPAddress.S_un.S_un_b.s_b1=127;
    m_SreverIPAddress.S_un.S_un_b.s_b2=0;
    m_SreverIPAddress.S_un.S_un_b.s_b3=0;
    m_SreverIPAddress.S_un.S_un_b.s_b4=1;
    m_iServerPortNumber=static_cast<u_short>(0);
    for (int i=0;i<MAX_SOCKET;i++)
    {
      m_ClientSocket[i]=INVALID_SOCKET;
      m_SocketEvents[i]=nullptr;
    }
    m_nClients=0;
  }
  return TRUE;
}
//================================================================
BOOL CSo7_TCPIP_Server::GetHostIPAddr(in_addr& _IPAddress)
{
  static int first = TRUE;
  if (first)
  {
    if(m_Socket == INVALID_SOCKET)
    {
      return FALSE;
    }
    char HostName[100];
    gethostname(HostName,sizeof(HostName));
    hostent *pAddr;
    pAddr=gethostbyname(HostName);
    memcpy(&m_SreverIPAddress,pAddr->h_addr_list[0],sizeof(in_addr));
    _IPAddress=m_SreverIPAddress;
    first = FALSE;
  }
  _IPAddress=m_SreverIPAddress;
  return TRUE;
}
//================================================================
BOOL CSo7_TCPIP_Server::CreateAndListen()
{
  if(m_Socket == INVALID_SOCKET)
    ::closesocket(m_Socket);

  // 创建套节字
  m_Socket = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if(m_Socket == INVALID_SOCKET)
    return FALSE;

  // 填写要关联的本地地址
  sockaddr_in sin;
  sin.sin_family = AF_INET;
  sin.sin_port = htons(m_iServerPortNumber);
  sin.sin_addr.s_addr = INADDR_ANY;
  // 绑定端口
  if(::bind(m_Socket, (sockaddr*)&sin, sizeof(sin)) == SOCKET_ERROR)
  {
    return FALSE;
  }

  // 设置socket为窗口通知消息类型
  //::WSAAsyncSelect(m_Socket, m_hMsgWnd, WM_SOCKET, FD_ACCEPT|FD_CLOSE);

  WSAEVENT m_SocketEvent = ::WSACreateEvent();
  ::WSAEventSelect(m_Socket, m_SocketEvent, FD_ACCEPT|FD_CLOSE);
  m_SocketEvents[m_nClients] = m_SocketEvent;
  m_ClientSocket[m_nClients] = m_Socket;
  m_nClients++;
  // 进入监听模式
  ::listen(m_Socket, 5);
  Create_Thread();

  return TRUE;
}
//================================================================
void CSo7_TCPIP_Server::Create_Thread()
{
  if (!m_Thread_Id)
  {
    m_Thread_State  = TCPIP_THREAD_RUNNING;
    m_Thread_Id     = CreateThread((LPSECURITY_ATTRIBUTES)NULL,0,(LPTHREAD_START_ROUTINE)m_Thread,(LPVOID)this,0,NULL);
    m_Thread_Mutex  = CreateMutex(NULL,FALSE,NULL);
    m_MultiThread_Mutex  = CreateMutex(NULL,FALSE,NULL);
  }
}
//================================================================
void CSo7_TCPIP_Server::Exit_Thread()
{
  m_Thread_State = TCPIP_THREAD_EXIT;
  for (int i = 0; i < m_nClients; i++)
  {
    ::WSASetEvent(m_SocketEvents[i]);
  }

  if(m_Thread_Id)
  {
    DWORD dwCode = STILL_ACTIVE;
    while(dwCode == STILL_ACTIVE)
    {
      GetExitCodeThread(m_Thread_Id,&dwCode);
      Sleep(1);
    }
  }

  m_Thread_State = TCPIP_THREAD_EXIT;
  ReleaseMutex(m_Thread_Mutex);
  CloseHandle(m_Thread_Mutex);
  ReleaseMutex(m_MultiThread_Mutex);
  CloseHandle(m_MultiThread_Mutex);  
  m_Thread_Id=NULL;
}
//================================================================
unsigned __stdcall CSo7_TCPIP_Server::m_Thread(LPVOID pThis)
{
  CSo7_TCPIP_Server* _This = (CSo7_TCPIP_Server*)pThis;
  for(;;)
  {
    if(m_Thread_State == TCPIP_THREAD_EXIT)
      ExitThread(0);

    switch(m_Thread_State)
    {
    case TCPIP_THREAD_RUNNING:
      {
        // 在所有事件对象上等待
        int nIndex = ::WSAWaitForMultipleEvents(m_nClients, m_SocketEvents, FALSE, WSA_INFINITE, FALSE);
        // 对每个事件调用WSAWaitForMultipleEvents函数，以便确定它的状态
        nIndex = nIndex - WSA_WAIT_EVENT_0;
        {
          int i=nIndex;
          // 获取到来的通知消息，WSAEnumNetworkEvents函数会自动重置受信事件
          WSANETWORKEVENTS event;
          ::WSAEnumNetworkEvents(m_ClientSocket[i], m_SocketEvents[i], &event);
          if (event.lNetworkEvents & FD_ACCEPT)                // 处理FD_ACCEPT通知消息
          {
            _This->OnSocket(m_ClientSocket[i], FD_ACCEPT);
          }
          else if (event.lNetworkEvents & FD_CONNECT)                // 处理FD_ACCEPT通知消息
          {
            _This->OnSocket(m_ClientSocket[i], FD_CONNECT);
          }
          else if (event.lNetworkEvents & FD_READ)            // 处理FD_READ通知消息
          {
            _This->OnSocket(m_ClientSocket[i], FD_READ);
          }
          else if (event.lNetworkEvents & FD_CLOSE)        // 处理FD_CLOSE通知消息
          {
            _This->OnSocket(m_ClientSocket[i], FD_CLOSE);
          }
          else if (event.lNetworkEvents & FD_WRITE)        // 处理FD_WRITE通知消息
          {
            _This->OnSocket(m_ClientSocket[i], FD_WRITE);
          }
        }
        break;
      }
    case TCPIP_THREAD_PAUSED:
      {
        break;
      }
    case TCPIP_THREAD_EXIT:
      {
        ExitThread(0);
        break;
      }
    }
  };
  m_Thread_State=TCPIP_THREAD_EXIT;
  ExitThread(0);
}
//================================================================
BOOL CSo7_TCPIP_Server::AddClient(SOCKET s)
{
  if(m_nClients < WSA_MAXIMUM_WAIT_EVENTS)
  {
    WSAEVENT _SocketEvent = ::WSACreateEvent();
    ::WSAEventSelect(s, _SocketEvent, FD_READ|FD_WRITE|FD_CLOSE);
    m_SocketEvents[m_nClients] = _SocketEvent;
    m_ClientSocket[m_nClients] = s;
    m_nClients++;
    return TRUE;
  }
  return FALSE;
}
//================================================================
void CSo7_TCPIP_Server::RemoveClient(SOCKET s)
{
  BOOL bFind = FALSE;
  int i(0);
  for(i=0; i<m_nClients; i++)
  {
    if(m_ClientSocket[i] == s)
    {
      bFind = TRUE;
      break;
    }
  }
  // 如果找到就将此成员从列表中移除
  if(bFind)
  {
    m_nClients--;
    // 将此成员后面的成员都向前移动一个单位
    for(int j=i; j<m_nClients; j++)
    {
      m_ClientSocket[j] = m_ClientSocket[j+1];
      m_SocketEvents[j] = m_SocketEvents[j+1];
    }
  }
}
//================================================================
BOOL CSo7_TCPIP_Server::UpdateActiveClient(SOCKET s)
{
  BOOL bFind = FALSE;
  int i(0);
  m_nActiveClient=0;
  for(i=0; i<m_nClients; i++)
  {
    if(m_ClientSocket[i] == s)
    {
      bFind = TRUE;
      m_nActiveClient=i;
      break;
    }
  }
  return bFind;
}

//================================================================
void CSo7_TCPIP_Server::CloseAllSocket()
{
  // 关闭监听套节字
  if(m_Socket != INVALID_SOCKET)
  {
    ::closesocket(m_Socket);
    m_Socket = INVALID_SOCKET;
  }

  // 关闭所有客户的连接
  for(int i=0; i<m_nClients; i++)
  {
    ::closesocket(m_ClientSocket[i]);
    m_ClientSocket[i]= INVALID_SOCKET;
  }
  m_nClients = 0;
}

//================================================================
BOOL CSo7_TCPIP_Server::RESPONSE_PLC_DM_UNKNOWN(short _DataSize)
{
  if(m_ClientSocket[m_nActiveClient] == INVALID_SOCKET)
  {    
    return FALSE;
  }
  m_ClearSendBuf();
#ifdef PLC_KEYENCE
  short sData=0;

  for(int i=0;i<_DataSize;i++)
  {
    int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
    sprintf_s(&m_TCPIPBuf[CH_SEND]._buffer[iBufSize],TCPIP_MAX_BUFF_SIZE-iBufSize,"%05u ",(unsigned short)sData);
  }  
  int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize-1]=0x0D;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize++]=0x0A;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize]=0x00;
  m_TCPIPBuf[CH_SEND]._size=iBufSize;
#else
  memcpy(m_TCPIPBuf[CH_SEND]._buffer,DRW_SData,sizeof(DRW_SData));
  m_TCPIPBuf[CH_SEND]._size=DRW_SDataIndexData;
#endif
  SendBuffer();
  return TRUE;
}

//================================================================
BOOL CSo7_TCPIP_Server::Response_Handshake()
{
  if(m_ClientSocket[m_nActiveClient] == INVALID_SOCKET)
  {
    return FALSE;
  }
#ifdef PLC_KEYENCE
  m_ClearSendBuf();
#else
  m_ClearSendBuf();
  memcpy(m_TCPIPBuf[CH_SEND]._buffer,HandShaking,sizeof(HandShaking));
  m_TCPIPBuf[CH_SEND]._size=sizeof(HandShaking);
  SendBuffer();
#endif
  return TRUE;
}

//================================================================
BOOL CSo7_TCPIP_Server::Response_PLC_DM200_R(short _StartAddr,short _DataSize)
{
  if(m_ClientSocket[m_nActiveClient] == INVALID_SOCKET)
  {    
    return FALSE;
  }
  m_ClearSendBuf();
  memcpy(m_TCPIPBuf[CH_SEND]._buffer,DRW_SData,sizeof(DRW_SData));
  _StartAddr-=200;
  if ((_StartAddr+_DataSize)>=MAX_DM_PAGE_NUMBER)
  {
    _DataSize=MAX_DM_PAGE_NUMBER-_StartAddr;
  }

#ifdef PLC_KEYENCE

  for(int i=0;i<_DataSize;i++)
  {
    int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
    sprintf_s(&m_TCPIPBuf[CH_SEND]._buffer[iBufSize],TCPIP_MAX_BUFF_SIZE-iBufSize,"%05u ",(unsigned short)DM200[_StartAddr+i]);
  }  
  int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize-1]=0x0D;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize++]=0x0A;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize]=0x00;
  m_TCPIPBuf[CH_SEND]._size=iBufSize;
#else
  for (int i=0;i<_DataSize;i++)
  {
    sData=DM200[_StartAddr+i];
    m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexData+2*i]=(sData>>8) & 0x0ff;
    m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexData+2*i+1]=sData & 0x0ff;
  }
  short sDataSize(0);
  sDataSize=(DRW_SDataIndexData-DRW_SDataHeadDataSize+_DataSize*2);
  m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexDataSize1]=static_cast<char>((sDataSize>>8) & 0x0ff);
  m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexDataSize2]=static_cast<char>(sDataSize & 0x0ff);
  m_TCPIPBuf[CH_SEND]._size=DRW_SDataIndexData+_DataSize*2;
#endif

  SendBuffer();

  return TRUE;
}
//================================================================
BOOL CSo7_TCPIP_Server::Response_PLC_DM5000_R(short _StartAddr,short _DataSize)
{
  if(m_ClientSocket[m_nActiveClient] == INVALID_SOCKET)
  {    
    return FALSE;
  }
  m_ClearSendBuf();
  _StartAddr-=5000;
  if ((_StartAddr+_DataSize)>=MAX_DM_PAGE_NUMBER)
  {
    _DataSize=MAX_DM_PAGE_NUMBER-_StartAddr;
  }
#ifdef PLC_KEYENCE

  for(int i=0;i<_DataSize;i++)
  {
    int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
    sprintf_s(&m_TCPIPBuf[CH_SEND]._buffer[iBufSize],TCPIP_MAX_BUFF_SIZE-iBufSize,"%05u ",(unsigned short)DM5000[_StartAddr+i]);
  }  
  int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize-1]=0x0D;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize++]=0x0A;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize]=0x00;
  m_TCPIPBuf[CH_SEND]._size=iBufSize;
#else
  memcpy(m_TCPIPBuf[CH_SEND]._buffer,DRW_SData,sizeof(DRW_SData));
  for (int i=0;i<_DataSize;i++)
  {
    sData=DM5000[_StartAddr+i];
    m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexData+2*i]=(sData>>8) & 0x0ff;
    m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexData+2*i+1]=sData & 0x0ff;
  }  
  short sDataSize(0);
  sDataSize=(DRW_SDataIndexData-DRW_SDataHeadDataSize+_DataSize*2);
  m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexDataSize1]=static_cast<char>((sDataSize>>8) & 0x0ff);
  m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexDataSize2]=static_cast<char>(sDataSize & 0x0ff);
  m_TCPIPBuf[CH_SEND]._size=DRW_SDataIndexData+_DataSize*2;
#endif
  SendBuffer();

  return TRUE;
}
//================================================================
BOOL CSo7_TCPIP_Server::Response_PLC_DM20000_R(short _StartAddr,short _DataSize)
{
  if(m_ClientSocket[m_nActiveClient] == INVALID_SOCKET)
  {    
    return FALSE;
  }
  m_ClearSendBuf();

  unsigned long lStartAddr=static_cast<unsigned long>(_StartAddr-20000);
  if ((lStartAddr+_DataSize)>=MAX_DM_PAGE_NUMBER)
  {
    lStartAddr=MAX_DM_PAGE_NUMBER-lStartAddr;
  }
#ifdef PLC_KEYENCE

  for(int i=0;i<_DataSize;i++)
  {
    int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
    sprintf_s(&m_TCPIPBuf[CH_SEND]._buffer[iBufSize],TCPIP_MAX_BUFF_SIZE-iBufSize,"%05u ",(unsigned short)DM10000[lStartAddr+i]);
  }  
  int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize-1]=0x0D;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize++]=0x0A;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize]=0x00;
  m_TCPIPBuf[CH_SEND]._size=iBufSize;
#else
  memcpy(m_TCPIPBuf[CH_SEND]._buffer,DRW_SData,sizeof(DRW_SData));
  for (int i=0;i<_DataSize;i++)
  {
    sData=DM10000[_StartAddr+i];
    m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexData+2*i]=(sData>>8) & 0x0ff;
    m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexData+2*i+1]=sData & 0x0ff;
  }  
  short sDataSize(0);
  sDataSize=(DRW_SDataIndexData-DRW_SDataHeadDataSize+_DataSize*2);
  m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexDataSize1]=static_cast<char>((sDataSize>>8) & 0x0ff);
  m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexDataSize2]=static_cast<char>(sDataSize & 0x0ff);

  m_TCPIPBuf[CH_SEND]._size=DRW_SDataIndexData+_DataSize*2;
#endif
  SendBuffer();

  return TRUE;
}

//================================================================
BOOL CSo7_TCPIP_Server::Response_PLC_DM10000_R(short _StartAddr,short _DataSize)
{
  if(m_ClientSocket[m_nActiveClient] == INVALID_SOCKET)
  {    
    return FALSE;
  }
  m_ClearSendBuf();

  _StartAddr-=10000;
  if ((_StartAddr+_DataSize)>=MAX_DM_PAGE_NUMBER)
  {
    _DataSize=MAX_DM_PAGE_NUMBER-_StartAddr;
  }
#ifdef PLC_KEYENCE

  for(int i=0;i<_DataSize;i++)
  {
    int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
    sprintf_s(&m_TCPIPBuf[CH_SEND]._buffer[iBufSize],TCPIP_MAX_BUFF_SIZE-iBufSize,"%05u ",(unsigned short)DM10000[_StartAddr+i]);
  }  
  int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize-1]=0x0D;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize++]=0x0A;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize]=0x00;
  m_TCPIPBuf[CH_SEND]._size=iBufSize;
#else
  memcpy(m_TCPIPBuf[CH_SEND]._buffer,DRW_SData,sizeof(DRW_SData));
  for (int i=0;i<_DataSize;i++)
  {
    sData=DM10000[_StartAddr+i];
    m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexData+2*i]=(sData>>8) & 0x0ff;
    m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexData+2*i+1]=sData & 0x0ff;
  }  
  short sDataSize(0);
  sDataSize=(DRW_SDataIndexData-DRW_SDataHeadDataSize+_DataSize*2);
  m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexDataSize1]=static_cast<char>((sDataSize>>8) & 0x0ff);
  m_TCPIPBuf[CH_SEND]._buffer[DRW_SDataIndexDataSize2]=static_cast<char>(sDataSize & 0x0ff);

  m_TCPIPBuf[CH_SEND]._size=DRW_SDataIndexData+_DataSize*2;
#endif
  SendBuffer();

  return TRUE;
}


//================================================================
BOOL CSo7_TCPIP_Server::RESPONSE_PLC_DM36000_R(short _StartAddr,short _DataSize)
{
  if(m_ClientSocket[m_nActiveClient] == INVALID_SOCKET)
  {    
    return FALSE;
  }
  m_ClearSendBuf();
  short DM36000[100]={0};
  int m_CCDData_D36000[20]={0};
  int iDataNumber(1);
  int Index(0);
  for (int iFix=0;iFix<2;iFix++)
  {
    m_CCDData_D36000[Index++]=(0xA001+iFix)*1000;
    double dRand(0.0);

    if(iDataNumber>0)
      m_CCDData_D36000[Index++]=iDataNumber*1000;
    double dRandMin=0.0;
    double  dRandMax=1.0;
    static int iTestCnts=0;
    iTestCnts++;
    for (int ii=0;ii<iDataNumber;ii++)
    {
      dRandMin=iTestCnts-1.0;
      dRandMax=iTestCnts;
      dRand=dRandMin+(dRandMax-dRandMin)*rand()/(RAND_MAX*1.0);
      m_CCDData_D36000[Index++]=static_cast<int>(dRand*1000);
    }
  }
  m_CCDData_D36000[0]=(Index)*1000;

  int iData(0);        
  BYTE DM_Data[4]={0,0,0,0};
  int StartAddr(0);
  for (int i=0;i<20;i++)
  {
    iData=m_CCDData_D36000[i];
    DM_Data[0]=(iData>>24) & 0x0ff;
    DM_Data[1]=(iData>>16) & 0x0ff;
    DM_Data[2]=(iData>>8) & 0x0ff;
    DM_Data[3]=iData & 0x0ff;
    DM36000[StartAddr+2*i]=(DM_Data[2]<<8)+DM_Data[3];
    DM36000[StartAddr+2*i+1]=(DM_Data[0]<<8)+DM_Data[1];
  }  
  _StartAddr-=36000;
  if ((_StartAddr+_DataSize)>=MAX_DM_PAGE_NUMBER)
  {
    _DataSize=MAX_DM_PAGE_NUMBER-_StartAddr;
  }
  for(int i=0;i<_DataSize;i++)
  {
    int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
    sprintf_s(&m_TCPIPBuf[CH_SEND]._buffer[iBufSize],TCPIP_MAX_BUFF_SIZE-iBufSize,"%05u ",(unsigned short)DM36000[_StartAddr+i]);
  }  
  int iBufSize=strlen(m_TCPIPBuf[CH_SEND]._buffer);
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize-1]=0x0D;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize++]=0x0A;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize]=0x00;
  m_TCPIPBuf[CH_SEND]._size=iBufSize;
  SendBuffer();

  return TRUE;
}
//================================================================
BOOL CSo7_TCPIP_Server::_Send_Cmd_Write_State()
{
  if(m_ClientSocket[m_nActiveClient] == INVALID_SOCKET)
  {    
    return FALSE;
  }
  m_ClearSendBuf();
#ifdef PLC_KEYENCE
  int iBufSize=0;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize++]='O';
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize++]='K';
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize++]=0x0D;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize++]=0x0A;
  m_TCPIPBuf[CH_SEND]._buffer[iBufSize]=0x00;
  m_TCPIPBuf[CH_SEND]._size=iBufSize;
#else
  m_TCPIPBuf[CH_SEND]._size=0;
#endif
  SendBuffer();

  return TRUE;
}
//================================================================
LRESULT CSo7_TCPIP_Server::OnSocket(WPARAM wParam, LPARAM lParam)
{
  SOCKET s = wParam;
  switch (lParam)
  {	
  case FD_ACCEPT:
    {
      if(m_nClients < WSA_MAXIMUM_WAIT_EVENTS)
      {
        SOCKET client = ::accept(s, NULL, NULL);
        AddClient(client);
      }
      else
      {
        AfxMessageBox(_T("连接客户太多！"));
      };
      ::SendMessage(m_hMsgWnd,WM_TCPIP_MSG,FD_ACCEPT,0);
    }
    break;
  case FD_READ:
    {
      UpdateActiveClient(s);

      m_ProcessSocketReadEvent(s);
    }
    break;
  case FD_WRITE:
    //This event happens when the tcp buffers are ready for another send.
    //So if there is not enough room for the first write the event will happen
    //and then the buffers are ready for more.
    m_ProcessSocketWriteEvent();
    ::SendMessage(m_hMsgWnd,WM_TCPIP_MSG,FD_WRITE,0);
    break;
  case FD_CLOSE:
    {
      RemoveClient(s);
      ::closesocket(s);
      ::SendMessage(m_hMsgWnd,WM_TCPIP_MSG,FD_CLOSE,0);
    }
    break;
  }
  return 0;
}
//================================================================
void CSo7_TCPIP_Server::m_ClearSendBuf(void)
{
  int i;
  for(i=0;i<TCPIP_MAX_BUFF_SIZE;i++)
  {
    m_TCPIPBuf[CH_SEND]._buffer[i] = 0x0;
  }
  m_TCPIPBuf[CH_SEND]._CompletedSize=0;
  m_TCPIPBuf[CH_SEND]._size=0;
  m_TCPIPBuf[CH_RECV]._CompletedSize=0;
  m_TCPIPBuf[CH_RECV]._size=0;
}
//================================================================
void CSo7_TCPIP_Server::SendBuffer()
{
  int errorCode, numBytesSent;
  bool bInfinite=true;
  while(bInfinite)
  {
    numBytesSent = send(m_ClientSocket[m_nActiveClient], &(m_TCPIPBuf[CH_SEND]._buffer[m_TCPIPBuf[CH_SEND]._CompletedSize]), m_TCPIPBuf[CH_SEND]._size-m_TCPIPBuf[CH_SEND]._CompletedSize, 0);
    if(numBytesSent == SOCKET_ERROR)
    {
      errorCode = WSAGetLastError();
      if(errorCode == WSAEWOULDBLOCK)
      {
        m_TCPIPBuf[CH_SEND]._hProtoPending=FALSE;
        return;  //Should get a FD_WRITE event if this happens.  Send the rest from there.
      }
      m_TCPIPBuf[CH_SEND]._hProtoPending=FALSE;
      return;  //should check for other errors here, and set an error code or something.
    }
    else
    {
      m_TCPIPBuf[CH_SEND]._CompletedSize += numBytesSent;
    }
    if(m_TCPIPBuf[CH_SEND]._CompletedSize>=m_TCPIPBuf[CH_SEND]._size)
    {
      m_TCPIPBuf[CH_SEND]._size = 0;
      m_TCPIPBuf[CH_SEND]._CompletedSize = 0;
      m_TCPIPBuf[CH_SEND]._hProtoPending=FALSE;
      break;
    }
  }
}

//================================================================
void CSo7_TCPIP_Server::m_ProcessSocketWriteEvent(void)
{
  int errorCode, numBytesSent;
  SOCKET s = m_Socket;
  if(m_TCPIPBuf[CH_SEND]._size <= 0)
    return;
  char* sendBuf = m_TCPIPBuf[CH_SEND]._buffer;

  while(1)
  {
    numBytesSent = send(s, &(sendBuf[m_TCPIPBuf[CH_SEND]._CompletedSize]), m_TCPIPBuf[CH_SEND]._size-m_TCPIPBuf[CH_SEND]._CompletedSize, 0);
    if(numBytesSent == SOCKET_ERROR)
    {
      errorCode = WSAGetLastError();
      if(errorCode == WSAEWOULDBLOCK)
      {
        return;  //Should get a FD_WRITE event if this happens.  Send the rest from there.
      }
      else
      {
        //showSocketError(errorCode);
        return;
      }
    }
    else
    {
      m_TCPIPBuf[CH_SEND]._CompletedSize += numBytesSent;
    }
    if(m_TCPIPBuf[CH_SEND]._CompletedSize>=m_TCPIPBuf[CH_SEND]._size)
    {
      m_TCPIPBuf[CH_SEND]._CompletedSize = 0;
      m_ClearSendBuf();
      break;
    }
  }
}
//================================================================
void CSo7_TCPIP_Server::m_ProcessSocketReadEvent(SOCKET s)
{
  int bytesReceived=0;
  int errorCode;

  bytesReceived = recv(s, &(m_TCPIPBuf[CH_RECV]._buffer[0]), TCPIP_MAX_BUFF_SIZE, 0);
  if(bytesReceived == SOCKET_ERROR)
  {
    errorCode = WSAGetLastError();
    if (errorCode == WSAEWOULDBLOCK)
    {
      //have to wait for the next receive event
      return;
    }
    else
    {
      //showSocketError(errorCode);
      return;
    }
  }
  m_TCPIPBuf[CH_RECV]._CompletedSize += bytesReceived;
  m_TCPIPBuf[CH_RECV]._size = m_TCPIPBuf[CH_RECV]._CompletedSize;
  m_TCPIPMsg.Init();
  TRACE0("m_ProcessSocketReadEvent\r\n");
#ifdef PLC_KEYENCE
  if (strstr(m_TCPIPBuf[CH_RECV]._buffer, "RD"))
  {
    unsigned long iAddr(0);
    unsigned long iDataSize(1);

    char cRecvDataTmp[30]={0};
    int iRecvDataIndex(0);
    int iBufferSize=m_TCPIPBuf[CH_RECV]._size;
    int index(0);
    iRecvDataIndex=0;
    int iLoopCount(0);
    do 
    {
      cRecvDataTmp[index++]=m_TCPIPBuf[CH_RECV]._buffer[iRecvDataIndex++];
      if (m_TCPIPBuf[CH_RECV]._buffer[iRecvDataIndex]==0x20
        ||m_TCPIPBuf[CH_RECV]._buffer[iRecvDataIndex]==0x0D)
      {
        if (iLoopCount==1)
        {
          char cTmp[30]={0};
          int iii(0);
          for (int i=0;i<index;i++)
          {
            if ('0'<=cRecvDataTmp[i]&&cRecvDataTmp[i]<='9')
            {
              cTmp[iii++]=cRecvDataTmp[i];
            }
          }
          iAddr=static_cast<unsigned long>(atoi(cTmp));
        }
        else if (iLoopCount==2)
        {
          iDataSize=static_cast<unsigned long>(atoi(cRecvDataTmp));
        }
        iLoopCount++;
        index=0;
        memset(cRecvDataTmp,0,30*sizeof(char));
      } 
    } while (iRecvDataIndex<=iBufferSize&&m_TCPIPBuf[CH_RECV]._buffer[iRecvDataIndex]!=0x0D);


    m_TCPIPMsg._CmdType=0;
    m_TCPIPMsg._DataAddr=iAddr;
    m_TCPIPMsg._DataSize=iDataSize;
    if (iAddr>=36000)
    {
      RESPONSE_PLC_DM36000_R((short)iAddr,(short)iDataSize);
      m_TCPIPMsg._MsgType=RESPONSE_UNKNOWN;
      m_TCPIPMsg._MsgType=RESPONSE_READ_ERRCODE;
    }   
    else if (iAddr>=30000)
    {
      RESPONSE_PLC_DM_UNKNOWN((short)iDataSize);
      m_TCPIPMsg._MsgType=RESPONSE_UNKNOWN;
      m_TCPIPMsg._MsgType=RESPONSE_READ_ERRCODE;
    }   
    else if (iAddr>=28000)
    {
      RESPONSE_PLC_DM_UNKNOWN((short)iDataSize);
      m_TCPIPMsg._MsgType=RESPONSE_UNKNOWN;
    }
    else if (iAddr>=26000)
    {
      short saddr=(short)(iAddr-6000+800);
      Response_PLC_DM20000_R((short)saddr,(short)iDataSize);
      m_TCPIPMsg._MsgType=RESPONSE_READ_CCD_DATA;
    }
    else if (iAddr>=22000)
    {
      Response_PLC_DM20000_R((short)iAddr,(short)iDataSize);
      m_TCPIPMsg._MsgType=RESPONSE_READ_CCD_DATA;
    }
    else if (iAddr>=20000)
    {
      Response_PLC_DM20000_R((short)iAddr,(short)iDataSize);
      m_TCPIPMsg._MsgType=RESPONSE_READ_CCD_DATA;
    }
    else if (iAddr>=10000)
    {
      Response_PLC_DM10000_R((short)iAddr,(short)iDataSize);
      m_TCPIPMsg._MsgType=RESPONSE_READ_CCD_DATA;
    }
    else if (iAddr>=5100)
    {
      Response_PLC_DM5000_R((short)iAddr,(short)iDataSize);
      m_TCPIPMsg._MsgType=RESPONSE_READ_PLC_CALIB_POS;
    }
    else if (iAddr>=5000)
    {
      Response_PLC_DM5000_R((short)iAddr,(short)iDataSize);
      m_TCPIPMsg._MsgType=RESPONSE_READ_PLC_STATE;
    }
    else if (iAddr>=200)
    {
      Response_PLC_DM200_R((short)iAddr,(short)iDataSize);
      m_TCPIPMsg._MsgType=RESPONSE_READ_PLC_STATE;
    }
    else
    {
      RESPONSE_PLC_DM_UNKNOWN((short)iDataSize);
      m_TCPIPMsg._MsgType=RESPONSE_UNKNOWN;
    }
  }
  else if (strstr(m_TCPIPBuf[CH_RECV]._buffer, "WR"))
  {
    short iAddr(0);
    short iDataSize(1);
    short sRecvData[1024]={0};
    int iRecvDataSize=0;

    char cRecvDataTmp[30]={0};
    int iRecvDataIndex(0);
    int iBufferSize=m_TCPIPBuf[CH_RECV]._size;
    int index(0);
    iRecvDataIndex=0;
    int iLoopCount(0);
    do 
    {
      cRecvDataTmp[index++]=m_TCPIPBuf[CH_RECV]._buffer[iRecvDataIndex++];
      if (m_TCPIPBuf[CH_RECV]._buffer[iRecvDataIndex]==0x20
        ||m_TCPIPBuf[CH_RECV]._buffer[iRecvDataIndex]==0x0D)
      {
        if (iLoopCount==1)
        {
          char cTmp[30]={0};
          int iii(0);
          for (int i=0;i<index;i++)
          {
            if ('0'<=cRecvDataTmp[i]&&cRecvDataTmp[i]<='9')
            {
              cTmp[iii++]=cRecvDataTmp[i];
            }
          }
          iAddr=static_cast<short>(atoi(cTmp));
        }
        else if (iLoopCount==2)
        {
          iDataSize=static_cast<short>(atoi(cRecvDataTmp));
        }
        else if (iLoopCount>=3)
        {
          sRecvData[iRecvDataSize++]=static_cast<short>(atoi(cRecvDataTmp));
        }
        iLoopCount++;
        index=0;
        memset(cRecvDataTmp,0,30*sizeof(char));
      } 
    } while (iRecvDataIndex<=iBufferSize&&m_TCPIPBuf[CH_RECV]._buffer[iRecvDataIndex]!=0x0D);

    m_TCPIPMsg._CmdType=1;
    m_TCPIPMsg._DataAddr=iAddr;
    m_TCPIPMsg._DataSize=iDataSize;
    if (iAddr>=8000)
    {       
      static clock_t m_FinishTime(0),m_StartTime(0),m_AverageTime(0),m_Count(0);
      int iStartAddr(0);
      iStartAddr=iAddr-8000;
      if (iStartAddr==11)
      {
        if (m_Count>0)
        {
          m_FinishTime=clock();
        }
        m_AverageTime+=m_FinishTime-m_StartTime;
        m_Count++;
        TRACE2("Bin Result=%d;Time=%d.\r\n",DM8000[iStartAddr],m_FinishTime-m_StartTime);
        m_StartTime=clock();
      }
      for (int i=0;i<iRecvDataSize;i++)
      {
        DM8000[iStartAddr++]=sRecvData[i];
      }
      m_TCPIPMsg._UpdateData=1;
      if (iAddr==8002 && DM8000[2]==1)
      {        
        DM5000[0]=1;
        m_TCPIPMsg._UpdateData=2;
      }
      _Send_Cmd_Write_State();
      m_TCPIPMsg._MsgType=RESPONSE_WRITE_PLC_STATE;
    }
    else if (iAddr>=200)
    {      
      int iStartAddr(0);
      iStartAddr=iAddr-200;
      for (int i=0;i<iRecvDataSize;i++)
      {
        DM200[iStartAddr++]=sRecvData[i];
        TRACE2("DM%d=%d\r\n",iStartAddr-1,DM200[iStartAddr-1]);
      }
      BOOL bStatus(false);
      bStatus=DM200[35]&0x0002;
      TRACE1("DM235=%d\r\n",DM200[35]);
      if (bStatus)
      {
        TRACE1("DM225=%d\r\n",DM200[25]);
        DM200[25]=DM200[25]&0xFFFB;
        TRACE1("DM225=%d\r\n",DM200[25]);
      }
      m_TCPIPMsg._UpdateData=2;
      _Send_Cmd_Write_State();
      m_TCPIPMsg._MsgType=RESPONSE_WRITE_PLC_STATE; 
    }
    else
    {
      _Send_Cmd_Write_State();
      m_TCPIPMsg._MsgType=RESPONSE_UNKNOWN;
    }
  }
#else
  if (strstr(m_TCPIPBuf[CH_RECV]._buffer, "FINS"))
  {
    if (m_TCPIPBuf[CH_RECV]._buffer[7]==0x0C)//handshake
    {
      Response_Handshake();
      m_TCPIPMsg._MsgType=RESPONSE_HANDSHAKE;
    }
    else if (m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexCMD1]==0x01
      &&m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexCMD2]==0x01)
    {
      short iAddr(0);
      short iDataSize(0);
      BYTE bData[2]={0,0};
      bData[0]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexAddr1];
      bData[1]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexAddr2];
      iAddr=(bData[0]<<8)+bData[1];
      bData[0]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexCh1];
      bData[1]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexCh2];
      iDataSize=(bData[0]<<8)+bData[1];
      m_TCPIPMsg._CmdType=0;
      m_TCPIPMsg._DataAddr=iAddr;
      m_TCPIPMsg._DataSize=iDataSize;
      if (iAddr>=20000)
      {
        m_TCPIPMsg._MsgType=RESPONSE_READ_ERRCODE;
      }
      else if (iAddr>=10000)
      {
        Response_PLC_DM10000_R(iAddr,iDataSize);
        m_TCPIPMsg._MsgType=RESPONSE_READ_CCD_DATA;
      }
      else if (iAddr>=5100)
      {
        Response_PLC_DM5000_R(iAddr,iDataSize);
        m_TCPIPMsg._MsgType=RESPONSE_READ_PLC_CALIB_POS;
      }
      else if (iAddr>=5000)
      {
        Response_PLC_DM5000_R(iAddr,iDataSize);
        m_TCPIPMsg._MsgType=RESPONSE_READ_PLC_STATE;
      }
      else if (iAddr>=200)
      {
        Response_PLC_DM200_R(iAddr,iDataSize);
        m_TCPIPMsg._MsgType=RESPONSE_READ_PLC_STATE;
      }
      else
      {
        RESPONSE_PLC_DM_UNKNOWN();
        m_TCPIPMsg._MsgType=RESPONSE_UNKNOWN;
      }
    }
    else if (m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexCMD1]==0x01
      &&m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexCMD2]==0x02)
    {     
      short iAddr(0);
      short iDataSize(0);
      BYTE bData[2]={0,0};
      bData[0]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexAddr1];
      bData[1]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexAddr2];
      iAddr=(bData[0]<<8)+bData[1];
      bData[0]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexCh1];
      bData[1]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexCh2];
      iDataSize=(bData[0]<<8)+bData[1];
      m_TCPIPMsg._CmdType=1;
      m_TCPIPMsg._DataAddr=iAddr;
      m_TCPIPMsg._DataSize=iDataSize;
      if (iAddr>=8000)
      {       
        int iBuffsize(0);
        int iStartAddr(0);
        iStartAddr=iAddr-8000;
        bData[0]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RSDataIndexBufSize1];
        bData[1]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RSDataIndexBufSize2];
        iBuffsize=(bData[0]<<8)+bData[1];
        iBuffsize-=DRW_RDataCCLen;
        for (int i=0;i<iBuffsize;i+=2)
        {
          bData[0]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexData+i];
          bData[1]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexData+i+1];
          DM8000[iStartAddr++]=(bData[0]<<8)+bData[1];
        }
        m_TCPIPMsg._UpdateData=1;
        if (DM8000[2]==1)
        {
          DM5000[0]=1;
          m_TCPIPMsg._UpdateData=2;
        }
        RESPONSE_PLC_DM_UNKNOWN();
        m_TCPIPMsg._MsgType=RESPONSE_WRITE_PLC_STATE;
      }
      else if (iAddr>=200)
      {      
        int iBuffsize(0);
        int iStartAddr(0);
        iStartAddr=iAddr-200;
        bData[0]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RSDataIndexBufSize1];
        bData[1]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RSDataIndexBufSize2];
        iBuffsize=(bData[0]<<8)+bData[1];
        iBuffsize-=DRW_RDataCCLen;
        for (int i=0;i<iBuffsize;i+=2)
        {
          bData[0]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexData+i];
          bData[1]=m_TCPIPBuf[CH_RECV]._buffer[DRW_RDataIndexData+i+1];
          DM200[iStartAddr++]=(bData[0]<<8)+bData[1];
          TRACE2("DM%d=%d\r\n",iStartAddr-1,DM200[iStartAddr-1]);
        }
        BOOL bStatus(false);
        bStatus=DM200[35]&0x0002;
        TRACE1("DM235=%d\r\n",DM200[35]);
        if (bStatus)
        {
          TRACE1("DM225=%d\r\n",DM200[25]);
          DM200[25]=DM200[25]&0xFFFB;
          TRACE1("DM225=%d\r\n",DM200[25]);
        }
        m_TCPIPMsg._UpdateData=2;
        RESPONSE_PLC_DM_UNKNOWN();
        m_TCPIPMsg._MsgType=RESPONSE_WRITE_PLC_STATE; 
      }
      else
      {
        RESPONSE_PLC_DM_UNKNOWN();
        m_TCPIPMsg._MsgType=RESPONSE_UNKNOWN;
      }
    }
  }
#endif
  m_TCPIPBuf[CH_RECV]._CompletedSize = 0;   
  m_TCPIPBuf[CH_RECV]._hProtoPending=FALSE;

  if (m_TCPIPMsg._MsgType!=RESPONSE_READ_PLC_STATE)
  {
    ::SendMessage(m_hMsgWnd,WM_TCPIP_MSG,FD_READ,LPARAM(&m_TCPIPMsg));
  }
}