industrialNETworX

Hi Vinay,

here comes some code for you. Hope this is helpfull.
It consists of functions to perform basic configuration and to handle the Class 1 connection.

I additionally provide the configuration functions since I tested with them and got it to work, though.

This is the order I chose for the initial configuration:

EIMPF_RegisterAssembly ( 0x80000001, 32, 1000);
EIMPF_RegisterAssembly ( 0x80000002, 32, 1000);
EIMPF_SetDeviceInfo();
EIMPF_SetTcpConfig();

 Then you should be able to start and stop the connection using the functions

EIMPF_OpenConnection()

and

EIMPF_CloseConnection().

And now the rest of the code:

void EIMPF_RegisterAssembly ( unsigned long ulInstance, 
                              unsigned long ulSize,  
                              unsigned long ulOffset )
{
  EIP_OBJECT_AS_PACKET_REGISTER_REQ_T tPacket;
  
  tPacket.tHead.ulCmd   = EIP_OBJECT_AS_REGISTER_REQ;
  tPacket.tHead.ulSrc   = (UINT32)0x10;
  tPacket.tHead.ulSrcId  = 0; 
  tPacket.tHead.ulDest   = (UINT32)0x20;
  tPacket.tHead.ulDestId  = 0;
  tPacket.tHead.ulSta   = 0;
  tPacket.tHead.ulLen   = EIP_OBJECT_AS_REGISTER_REQ_SIZE;
  tPacket.tHead.ulId    = 0;
  tPacket.tHead.ulExt    = 0;
    
  tPacket.tData.ulInstance = ulInstance;
  tPacket.tData.ulSize = ulSize;
  if (ulInstance & 1)
    tPacket.tData.ulFlags = 0;
  else
    tPacket.tData.ulFlags = EIP_AS_FLAG_READONLY;
  tPacket.tData.ulDPMOffset = ulOffset;
  
  xChannelPutPacket( hChannel, (CIFX_PACKET*)&tPacket, 0);  
}

void EIMPF_SetDeviceInfo(){
  EIP_OBJECT_ID_PACKET_SETDEVICEINFO_REQ_T    tDevPacket;
  tDevPacket.tHead.ulCmd    = EIP_OBJECT_ID_SETDEVICEINFO_REQ;
  tDevPacket.tHead.ulSrc    = (UINT32)0x10;
  tDevPacket.tHead.ulDest   = (UINT32)0x20;
  tDevPacket.tHead.ulSrcId  = 0;
  tDevPacket.tHead.ulDestId = 0;
  tDevPacket.tHead.ulSta    = 0;
  tDevPacket.tHead.ulId     = 0;
  tDevPacket.tHead.ulLen    = EIP_OBJECT_ID_SETDEVICEINFO_REQ_SIZE;
      
  tDevPacket.tData.ulVendId         = 283;
  tDevPacket.tData.ulProductType    = 12;
  tDevPacket.tData.ulProductCode    = 0x0102;
  tDevPacket.tData.ulMajRev         = 1;
  tDevPacket.tData.ulMinRev         = 1;
  tDevPacket.tData.ulSerialNumber   = 0;
  tDevPacket.tData.abProductName[0] = 10;
  memcpy(&tDevPacket.tData.abProductName[1], 
          "TestDevice", 
          tDevPacket.tData.abProductName[0]);
  xChannelPutPacket( hChannel, (CIFX_PACKET*)&tDevPacket, 0);  
}

void EIMPF_SetTcpConfig(){
  TCPIP_PACKET_IP_CMD_SET_CONFIG_REQ_T        tTcpPacket;
  unsigned long                               ulFlags = 0;
  tTcpPacket.tHead.ulCmd    = TCPIP_IP_CMD_SET_CONFIG_REQ;
  tTcpPacket.tHead.ulLen    = TCPIP_DATA_IP_CMD_SET_CONFIG_REQ_SIZE;
  tTcpPacket.tHead.ulSrc    = (UINT32)0x10;
  tTcpPacket.tHead.ulDest   = (UINT32)0x20;
  tTcpPacket.tHead.ulDestId = 0;
  tTcpPacket.tHead.ulSrcId  = 0;
  tTcpPacket.tHead.ulSta    = 0;
  tTcpPacket.tHead.ulId     = 0;
  tTcpPacket.tHead.ulRout   = 0;
  tTcpPacket.tHead.ulExt    = 0;
    
  ulFlags = 0;
  ulFlags |= IP_CFG_FLAG_SPEED_100MBIT;
  ulFlags |= IP_CFG_FLAG_AUTO_NEGOTIATE;
  ulFlags |= (IP_CFG_FLAG_IP_ADDR | IP_CFG_FLAG_NET_MASK | IP_CFG_FLAG_GATEWAY);
  tTcpPacket.tData.ulFlags            = ulFlags;
  tTcpPacket.tData.ulIpAddr           = 0xC0A8FD64; // 192.168.253.100
  tTcpPacket.tData.ulNetMask          = 0xFFFFFF00; // 255.255.255.0
  tTcpPacket.tData.ulGateway          = 0xC0A8FD01; // 192.168.253.1
  tTcpPacket.tData.abEthernetAddr[0]  = 0x00; 
  tTcpPacket.tData.abEthernetAddr[1]  = 0x02;
  tTcpPacket.tData.abEthernetAddr[2]  = 0x63;
  tTcpPacket.tData.abEthernetAddr[3]  = 0x54;
  tTcpPacket.tData.abEthernetAddr[4]  = 0x45;
  tTcpPacket.tData.abEthernetAddr[5]  = 0x36;
    
  xChannelPutPacket( atChannel[USED_EIMPF_CHANNEL].hChannel, (CIFX_PACKET*)&tTcpPacket, 0);  
}

UINT8 abOpenConnPath[] = { 0x34, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                           0x00, 0x00, 0x20, 0x04, 0x24, 0x01, 0x2C, 0x64,0x2C, 0x65 };

UINT8 abIpAddr[] = "192.168.253.140"; // ip address of the target

void EIMPF_OpenConnection()
{
  EIP_OBJECT_CM_PACKET_OPEN_CONN_REQ_T tCPacket;
  DEFAULT_PACKET_T                     tDPacket;
  UINT32                               ulErr = 0;
  UINT8*                               pbData;
  /* Open Connection */
  tCPacket.tHead.ulCmd    = EIP_OBJECT_CM_OPEN_CONN_REQ;
  tCPacket.tHead.ulSrc    = (UINT32)0x10;
  tCPacket.tHead.ulSrcId  = 0; 
  tCPacket.tHead.ulDest   = (UINT32)0x20;
  tCPacket.tHead.ulDestId = 0;
  tCPacket.tHead.ulSta    = 0;
  tCPacket.tHead.ulLen    = EIP_OBJECT_CM_OPEN_CONN_REQ_SIZE + sizeof(abIpAddr) + sizeof(abOpenConnPath);
  tCPacket.tHead.ulId     = 0;
  tCPacket.tHead.ulExt    = 0;
  tCPacket.tData.ulConnectionSn = 1;        /* serial number of the connection */
  tCPacket.tData.ulGRC          = 0;        /* Generic Error Code   */
  tCPacket.tData.ulERC          = 0;        /* Extendet Error Code  */
  /* Connection parameters.   */
  tCPacket.tData.ulTimeoutMult  = 3;
  tCPacket.tData.ulClassTrigger = 1;
  tCPacket.tData.ulProRpi       = 100000;
  tCPacket.tData.ulProParams    = 0x4810    
  tCPacket.tData.ulConRpi       = 100000;
  tCPacket.tData.ulConParams    = 0x2810;

  /* Connection path & module configuration.   */
  tCPacket.tData.ulHostDestSize   = 15;   /* length of the hostname/ip */
  tCPacket.tData.ulHostDestOffs   = sizeof(tCPacket.tData);
  tCPacket.tData.ulProdInhibit    = 1000; /* production inhibit time in ms */
  tCPacket.tData.ulPort           = 2222; // EtherNetIP port
  tCPacket.tData.ulOpenPathSize   = sizeof(abOpenConnPath)/2;
  tCPacket.tData.ulClosePathSize  = sizeof(abOpenConnPath)/2;
  tCPacket.tData.ulPathOffs       = sizeof(tCPacket.tData) + sizeof(abIpAddr);
  tCPacket.tData.ulConfig1Size    = 0;
  tCPacket.tData.ulConfig1Offs    = 0;
  tCPacket.tData.ulConfig2Size    = 0;
  tCPacket.tData.ulConfig2Offs    = 0;
  /* Data mapping information on our side.   */
  tCPacket.tData.ulClass        = 4;
  tCPacket.tData.ulInstance     = 1;
  tCPacket.tData.ulProConnPoint = 0x80000001;
  tCPacket.tData.ulConConnPoint = 0x80000002;
  tCPacket.tData.ulFwdOpenTimeout = 1000;
  /* store packet data into default packet */
  memcpy (&tDPacket, &tCPacket, sizeof(tCPacket));
  
  /* store ip address */
  memcpy(&tDPacket.abData[sizeof(tCPacket)-40], abIpAddr, sizeof(abIpAddr));
  /* store connection path */
  memcpy(&tDPacket.abData[sizeof(tCPacket)-40 + sizeof(abIpAddr)], abOpenConnPath, sizeof(abOpenConnPath));
  ulErr = xChannelPutPacket( atChannel[USED_EIMPF_CHANNEL].hChannel, (CIFX_PACKET*)&tDPacket, 0);  
}

UINT8 abCloseConnPath[] = { 0x34, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x20, 0x04, 0x24, 0x01, 0x2C, 0x64, 0x2C, 0x65 };
void EIMPF_CloseConnection()
{
  EIP_OBJECT_CM_PACKET_CLOSE_CONN_REQ_T  tClosePck;
  DEFAULT_PACKET_T                       tDPacket;
  
  tClosePck.tHead.ulDest           = 0x20;
  tClosePck.tHead.ulCmd            = EIP_OBJECT_CM_CLOSE_CONN_REQ;
  tClosePck.tHead.ulSrc            = 0x10;
  tClosePck.tHead.ulLen            = sizeof(EIP_OBJECT_CM_CLOSE_CONN_REQ_T) + sizeof(abCloseConnPath);
  tClosePck.tData.ulConnectionSn   = 1;
  tClosePck.tData.ulOpenPathSize   = 9;
  tClosePck.tData.ulClosePathSize  = 9;
  tClosePck.tData.ulPathOffs       = sizeof(tClosePck.tData);
  memcpy (&tDPacket, &tClosePck, sizeof(tClosePck));
  memcpy(&tDPacket.abData[sizeof(tClosePck,tData)], abCloseConnPath, sizeof(abCloseConnPath));
  xChannelPutPacket( atChannel[USED_EIMPF_CHANNEL].hChannel, (CIFX_PACKET*)&tDPacket, 0);   
}