MXIO Software Development Kit
C++ Sample Code Programming Guide
 All Classes Files Functions Variables Typedefs Macros Groups Pages
Classes | Macros | Typedefs | Functions | Variables
MultiThread.cpp File Reference

Connect Multi Devices by Thread More...

#include <stdio.h>
#include <stdlib.h>
#include "../../../../include/MXIO_V3_2500.h"

Classes

struct  _DEVICE_PARAMETERS
 

Macros

#define THREAD_QUANTITY   2
 

Typedefs

typedef struct _DEVICE_PARAMETERS DEVICE_PARAMETERS
 

Functions

int MXCreateLibrary (HMODULE *phMXIO_V3_2500, CMXIO_V3_2500 **pMXIO_V3_2500, char *szLibName)
 
int MXDestroyLibrary (HMODULE hMXIO_V3_2500, CMXIO_V3_2500 **pMXIO_V3_2500)
 
void WaitPressAnyKey ()
 
void PrtBlockErrorString (int iIndex, WORD wErrorCode)
 
void PrtChErrorString (int iIndex, BYTE bytErrorCode)
 
void CALLBACK ReadDataCallbackFunc (WORD wBlockQuantity, int *pRecvReadBlockData, void *pParam)
 
void PrintReadValue (int iIndex, CMXIO_V3_2500::MX_RECV_READ_BLOCK_DATA *pImp)
 
UINT ThreadRead1 (void *lParam)
 
UINT ThreadRead2 (void *lParam)
 
int main (int argc, char *argv[])
 
void CheckErr (int ihConnection, int iRet, char *szFunctionName)
 
void CALLBACK ReadDataCallbackFunc1 (WORD wBlockQuantity, int *pRecvReadBlockData, void *pParam)
 
void CALLBACK ReadDataCallbackFunc2 (WORD wBlockQuantity, int *pRecvReadBlockData, void *pParam)
 

Variables

HMODULE g_hMXIO_V3_2500 = NULL
 
CMXIO_V3_2500g_pMXIO_V3_2500 = NULL
 

Detailed Description

Connect Multi Devices by Thread

Date
09/11/2015
Author
Daniel Chang
Version
V1.0

Macro Definition Documentation

#define THREAD_QUANTITY   2

Typedef Documentation

Function Documentation

int MXCreateLibrary ( HMODULE *  phMXIO_V3_2500,
CMXIO_V3_2500 **  pMXIO_V3_2500,
char *  szLibName 
)
int MXDestroyLibrary ( HMODULE  hMXIO_V3_2500,
CMXIO_V3_2500 **  pMXIO_V3_2500 
)
void WaitPressAnyKey ( )
void PrtBlockErrorString ( int  iIndex,
WORD  wErrorCode 
)
void PrtChErrorString ( int  iIndex,
BYTE  bytErrorCode 
)
void CALLBACK ReadDataCallbackFunc ( WORD  wBlockQuantity,
int *  pRecvReadBlockData,
void *  pParam 
)
void PrintReadValue ( int  iIndex,
CMXIO_V3_2500::MX_RECV_READ_BLOCK_DATA pImp 
)
UINT ThreadRead1 ( void *  lParam)
UINT ThreadRead2 ( void *  lParam)
int main ( int  argc,
char *  argv[] 
)
/*******************************************************************************
* Copyright Moxa Inc.
*
*
* Date Author Comment
* 09/11/2015 Daniel Chang Created.
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "../../../../include/MXIO_V3_2500.h"
//-----------------------------------------------------------------
int MXCreateLibrary(HMODULE *phMXIO_V3_2500, CMXIO_V3_2500 **pMXIO_V3_2500, char *szLibName);
int MXDestroyLibrary(HMODULE hMXIO_V3_2500, CMXIO_V3_2500 **pMXIO_V3_2500);
void PrtBlockErrorString(int iIndex, WORD wErrorCode);
void PrtChErrorString(int iIndex, BYTE bytErrorCode);
void CALLBACK ReadDataCallbackFunc(WORD wBlockQuantity, int *pRecvReadBlockData, void *pParam);;
UINT ThreadRead1( void * lParam );
UINT ThreadRead2( void * lParam );
//-----------------------------------------------------------------
// For thread used
typedef struct _DEVICE_PARAMETERS{
char IPAddress[16];
WORD wPort;
DWORD dwTimeout;
char szMACAddr[18];
bool bStop;
//-----------------------------------------------------------------
HMODULE g_hMXIO_V3_2500 = NULL;
CMXIO_V3_2500 *g_pMXIO_V3_2500 = NULL;
//-----------------------------------------------------------------
int main(int argc, char *argv[])
{
char bytInputValue[64] = {'\0'};
char szIP[] = "192.168.127.253";
char szIP2[] = "192.168.127.250";
memset(&MxMACAddr, 0, sizeof(MxMACAddr));
char szMACAddr[18] = {'\0'};//"00-90-e8-00-00-41";
DWORD dwTimeout = 3000;
int ihConnection = 0;
int ihConnection2 = 0;
sprintf(AccountData.szUserName,"%s", (char*)"admin");
sprintf(AccountData.szPwd,"%s", (char*)"moxa");
//-----------------------------------------------
char IPAddress[16] = {'\0'};
char IPAddress2[16] = {'\0'};
char szTempBuf[16] = {'\0'};
WORD wPort = MXIO_V3_AGENT_PORT;
sprintf(IPAddress, "%s", szIP);
if (argc <= 1)
{
printf("Cmd Format: [IP Address] [Timeout] [TCP Port] [IP Address2]\n");
strcpy(IPAddress, szIP);
strcpy(IPAddress2, szIP2);
}
//
if (argc > 1)
sprintf(IPAddress, "%s", argv[1]);
if (argc > 2)
dwTimeout = atoi(argv[2]);
if (argc > 3)
wPort = atoi(argv[3]);
if (argc > 4)
sprintf(IPAddress2, "%s", argv[4]);
printf("Input IP Address=%s, TimeOut=%d, TCP Port=%d, IP Address2=%s\n",
IPAddress, dwTimeout, wPort, IPAddress2);
//-----------------------
int iRet = MXIO_V3_OK;
iRet = MXCreateLibrary(&g_hMXIO_V3_2500, &g_pMXIO_V3_2500, "MXIO_2500.dll");
printf("MXCreateLibrary() g_pMXIO_V3_2500=0x%p return %d(0x%X)\n", g_pMXIO_V3_2500, iRet, iRet);
//-----------------------
if (MXIO_V3_OK == iRet)
{
iRet = g_pMXIO_V3_2500->MXIO_Init();
printf("MXIO_Init() return %d(0x%X)\n", iRet, iRet);
}
//-----------------------
if (MXIO_V3_OK == iRet)
{
#define THREAD_QUANTITY 2
HANDLE hThread[THREAD_QUANTITY];
DWORD dwthread[THREAD_QUANTITY];
int iDevice = (sizeof(dwthread)/sizeof(dwthread[0]));
DEVICE_PARAMETERS *DeviceParameters = new DEVICE_PARAMETERS[iDevice];
//Initial
for(int i=0; i < iDevice; i++)
{
DeviceParameters[i].wPort = wPort;
DeviceParameters[i].dwTimeout = dwTimeout;
memcpy(DeviceParameters[i].MxMACAddr.bytMAC, MxMACAddr.bytMAC, sizeof(BYTE)*6);
DeviceParameters[i].AccountData = &AccountData;
DeviceParameters[i].bStop = FALSE;
}
//Thread [0]
strcpy(DeviceParameters[0].IPAddress, IPAddress);
hThread[0] = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)ThreadRead1, &DeviceParameters[0], 0, &dwthread[0] );
//Thread [1]
strcpy(DeviceParameters[1].IPAddress, IPAddress2);
hThread[1] = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)ThreadRead2, &DeviceParameters[1], 0, &dwthread[1] );
// allow the thread to do some work:
for (int i = 10; i > 0; i--)
{
Sleep(1000);
printf("main thread wait {%d} Seconds\n", i);
}
//Stop thread
for (int i = 0; i < iDevice; i++)
DeviceParameters[i].bStop = TRUE;
//wait thread finish
for (int i = 0; i < iDevice; i++)
{
DWORD dwRet = WaitForSingleObject(hThread[i], INFINITE);
printf("WaitForSingleObject [%d] Tread return %d(0x%X)\n", i, dwRet, dwRet);
}
//Free memory
delete [] DeviceParameters;
}
//-----------------------
if (NULL != g_hMXIO_V3_2500)
{
iRet = g_pMXIO_V3_2500->MXIO_Exit();
printf("MXIO_Exit() return %d(0x%X)\n", iRet, iRet);
iRet = MXDestroyLibrary(g_hMXIO_V3_2500, &g_pMXIO_V3_2500);
printf("MXDestroyLibrary() return %d(0x%X)\n", iRet, iRet);
}
return 0;
}
//-----------------------------------------------------------------
int MXCreateLibrary(HMODULE *phMXIO_V3_2500, CMXIO_V3_2500 **pMXIO_V3_2500, char *szLibName)
{
*phMXIO_V3_2500 = LoadLibrary(szLibName);
if (NULL == *phMXIO_V3_2500)
return (GetLastError());
PFNCREATEMXIO_V3_2500 pfnCreateMXIO_V3_2500 = (PFNCREATEMXIO_V3_2500)GetProcAddress(*phMXIO_V3_2500, "CreateMXIO_2500");
if (NULL == pfnCreateMXIO_V3_2500)
return (-1);
*pMXIO_V3_2500 = pfnCreateMXIO_V3_2500();
return 0;
}
//-----------------------------------------------------------------
int MXDestroyLibrary(HMODULE hMXIO_V3_2500, CMXIO_V3_2500 **pMXIO_V3_2500)
{
PFNDESTROYMXIO_V3_2500 pfnDestroyMXIO_V3_2500 = (PFNDESTROYMXIO_V3_2500)GetProcAddress(hMXIO_V3_2500, "DestroyMXIO_2500");
if (NULL == pfnDestroyMXIO_V3_2500)
return (GetLastError());
pfnDestroyMXIO_V3_2500(*pMXIO_V3_2500);
FreeLibrary(hMXIO_V3_2500);
*pMXIO_V3_2500 = NULL;
return 0;
}
//-----------------------------------------------------------------
{
system("pause");
}
//-----------------------------------------------------------------
//===========================================================================
void CheckErr(int ihConnection, int iRet, char *szFunctionName)
{
char *szErrMsg = "MXIO_V3_OK";
if (iRet != MXIO_V3_OK)
{
switch (iRet)
{
szErrMsg = "MXIO_V3_ILLEGAL_FUNCTION";
break;
szErrMsg = "MXIO_V3_ILLEGAL_DATA_ADDRESS";
break;
szErrMsg = "MXIO_V3_ILLEGAL_DATA_VALUE";
break;
szErrMsg = "MXIO_V3_SLAVE_DEVICE_FAILURE";
break;
szErrMsg = "MXIO_V3_SLAVE_DEVICE_BUSY";
break;
szErrMsg = "MXIO_V3_EIO_TIME_OUT";
break;
szErrMsg = "MXIO_V3_EIO_INIT_SOCKETS_FAIL";
break;
szErrMsg = "MXIO_V3_EIO_CREATING_SOCKET_ERROR";
break;
szErrMsg = "MXIO_V3_EIO_RESPONSE_BAD";
break;
szErrMsg = "MXIO_V3_EIO_SOCKET_DISCONNECT";
break;
szErrMsg = "MXIO_V3_PROTOCOL_TYPE_ERROR";
break;
szErrMsg = "MXIO_V3_PRODUCT_NOT_SUPPORT";
break;
szErrMsg = "MXIO_V3_HANDLE_ERROR";
break;
szErrMsg = "MXIO_V3_SLOT_OUT_OF_RANGE";
break;
szErrMsg = "MXIO_V3_CHANNEL_OUT_OF_RANGE";
break;
szErrMsg = "MXIO_V3_COIL_TYPE_ERROR";
break;
szErrMsg = "MXIO_V3_REGISTER_TYPE_ERROR";
break;
szErrMsg = "MXIO_V3_FUNCTION_NOT_SUPPORT";
break;
szErrMsg = "MXIO_V3_OUTPUT_VALUE_OUT_OF_RANGE";
break;
szErrMsg = "MXIO_V3_INPUT_VALUE_OUT_OF_RANGE";
break;
szErrMsg = "MXIO_V3_EIO_PASSWORD_INCORRECT";
break;
szErrMsg = "MXIO_V3_SLOT_NOT_EXIST";
break;
szErrMsg = "MXIO_V3_FIRMWARE_NOT_SUPPORT";
break;
szErrMsg = "MXIO_V3_CREATE_MUTEX_FAIL";
break;
szErrMsg = "MXIO_V3_ERR_ENUM_NET_INTERFACE_FAIL";
break;
szErrMsg = "MXIO_V3_ERR_SELECT_NET_INTERFACE_FAIL";
break;
szErrMsg = "MXIO_V3_ERR_FUNCTION_NOT_SUPPORT";
break;
szErrMsg = "MXIO_V3_ERR_INVALID_HANDLE";
break;
szErrMsg = "MXIO_V3_ERR_BLOCK_QUANTITY";
break;
szErrMsg = "MXIO_V3_ERR_TOTAL_BLOCK_SIZE";
break;
szErrMsg = "MXIO_V3_ERR_REACH_MXIO_LIMIT_CONNECTION";
break;
szErrMsg = "MXIO_V3_ERR_PARSE_XML_FAIL";
break;
szErrMsg = "MXIO_V3_ERR_ACCOUNT_VERIFY_FAIL";
break;
szErrMsg = "MXIO_V3_ERR_ACCOUNT_ACCESS_RIGHT";
break;
default:
szErrMsg = "Unknown Error Value";
break;
}
printf("%d Function \"%s\" execution Fail.\nError Message : %s (%d(0x%X))\n",
ihConnection, szFunctionName, szErrMsg, iRet, iRet);
}
else
{
printf("%d Function \"%s\" execution Success\n", ihConnection, szFunctionName);
}
}
//-----------------------------------------------------------------
void PrtBlockErrorString(int iIndex, WORD wErrorCode)
{
if (MXIO_V3_BLOCK_ERR_SIZE == wErrorCode)
printf("Block[%d] = BLOCK_ERR_SIZE\n", iIndex);
else if (MXIO_V3_BLOCK_ERR_TYPE == wErrorCode)
printf("Block[%d] = BLOCK_ERR_TYPE\n", iIndex);
else if (MXIO_V3_BLOCK_ERR_SUBTYPE == wErrorCode)
printf("Block[%d] = BLOCK_ERR_SUBTYPE\n", iIndex);
else if (MXIO_V3_BLOCK_ERR_FUNCTION == wErrorCode)
printf("Block[%d] = BLOCK_ERR_FUNCTION\n", iIndex);
else if (MXIO_V3_BLOCK_ERR_SLOT == wErrorCode)
printf("Block[%d] = BLOCK_ERR_SLOT\n", iIndex);
else if (MXIO_V3_BLOCK_ERR_START_OBJ == wErrorCode)
printf("Block[%d] = BLOCK_ERR_START_CHANNEL\n", iIndex);
else if (MXIO_V3_BLOCK_ERR_TOTAL_OBJ == wErrorCode)
printf("Block[%d] = BLOCK_ERR_TOTAL_CHANNEL\n", iIndex);
else
printf("Block[%d] = Not defined error code= %d\n", iIndex, wErrorCode);
}
//-----------------------------------------------------------------
void PrtChErrorString(int iIndex, BYTE bytErrorCode)
{
if (MXIO_V3_CH_OK == bytErrorCode)
printf("CH[%d] = SUCCESS\n", iIndex);
else if (MXIO_V3_CH_ERR_LOCKED == bytErrorCode)
printf("CH[%d] = ERROR_LOCKED\n", iIndex);
else if (MXIO_V3_CH_ERR_READ_ONLY == bytErrorCode)
printf("CH[%d] = ERROR_READ_ONLY\n", iIndex);
else if (MXIO_V3_CH_ERR_SUBTYPE == bytErrorCode)
printf("CH[%d] = ERROR_SUBTYPE\n", iIndex);
else if (MXIO_V3_CH_ERR_DATA_TYPE == bytErrorCode)
printf("CH[%d] = ERROR_DATA_TYPE\n", iIndex);
else if (MXIO_V3_CH_ERR_DATA == bytErrorCode)
printf("CH[%d] = ERROR_DATA\n", iIndex);
else if (MXIO_V3_CH_ERR_DISABLE == bytErrorCode)
printf("CH[%d] = ERROR_DISABLE\n", iIndex);
else if (MXIO_V3_CH_ERR_BOOLEAN_ONLY == bytErrorCode)
printf("CH[%d] = ERROR_BOOLEAN_ONLY\n", iIndex);
else if (MXIO_V3_CH_ERR_WRITE_FAIL== bytErrorCode)
printf("CH[%d] = MXIO_V3_CH_ERR_WRITE_FAIL\n", iIndex);
else
printf("CH[%d] = Not defined error code= %d\n", iIndex, bytErrorCode);
}
//-----------------------------------------------------------------
{
printf("iHConnection = %d\n", pImp->iHConnection);
BYTE bytDataType = pImp->pRwChannelData[iIndex].bytDataType;
if ((DATA_TYPE_BYTE == bytDataType) || (DATA_TYPE_WORD == bytDataType))
printf("[%d] = 0x%02X\n", iIndex, pImp->pRwChannelData[iIndex].unValue.dwValue);
else if ((DATA_TYPE_DWORD == bytDataType) || (DATA_TYPE_INT == bytDataType))
printf("[%d] = 0x%04X\n", iIndex, pImp->pRwChannelData[iIndex].unValue.dwValue);
else if (DATA_TYPE_FLOAT == bytDataType)
printf("[%d] = %.3f\n", iIndex, pImp->pRwChannelData[iIndex].unValue.fValue);
else if (DATA_TYPE_STRING == bytDataType)
printf("[%d] = %s\n", iIndex, pImp->pRwChannelData[iIndex].unValue.szValue);
}
//-----------------------------------------------------------------
void CALLBACK ReadDataCallbackFunc1(WORD wBlockQuantity, int *pRecvReadBlockData, void *pParam)
{
if (pReadImp)
{
{
printf("Read Block[%d] Success:\n", (wBlockQuantity-1));
for (int i = 0; i < pReadImp->MxRecvBlockHeader.wTotalObj; i++)
{
PrintReadValue(i, pReadImp);
else
}
}
else
PrtBlockErrorString((wBlockQuantity - 1), pReadImp->MxRecvBlockHeader.wResult);
}
}
//-----------------------------------------------------------------
void CALLBACK ReadDataCallbackFunc2(WORD wBlockQuantity, int *pRecvReadBlockData, void *pParam)
{
if (pReadImp)
{
{
printf("Read Block[%d] Success:\n", (wBlockQuantity-1));
for (int i = 0; i < pReadImp->MxRecvBlockHeader.wTotalObj; i++)
{
PrintReadValue(i, pReadImp);
else
}
}
else
PrtBlockErrorString((wBlockQuantity - 1), pReadImp->MxRecvBlockHeader.wResult);
}
}
//-----------------------------------------------------------------
UINT ThreadRead1( void * lParam )
{
int ihConnection = 0;
sprintf(io->szMACAddr, "%02X-%02X-%02X-%02X-%02X-%02X",
io->MxMACAddr.bytMAC[0],
io->MxMACAddr.bytMAC[1],
io->MxMACAddr.bytMAC[2],
io->MxMACAddr.bytMAC[3],
io->MxMACAddr.bytMAC[4],
io->MxMACAddr.bytMAC[5]);
printf("IP = %s, MAC = %s, Port=%d, Name=%s, Password=%s",
int iRet = g_pMXIO_V3_2500->MXIO_Connect(io->IPAddress, io->wPort, io->dwTimeout, &(io->MxMACAddr), io->AccountData, &ihConnection);
CheckErr(ihConnection, iRet, "MXIO_Connect");
printf("IP = %s, ihConnection = %d\r\n", io->IPAddress, ihConnection);
//-----------------------------------------------------
while(FALSE == io->bStop)
{
//Read
WORD wStartObj = 0, wTotalObj = 8;
CMXIO_V3_2500::MX_READ_BLOCK_DATA RwBlockDataArray[1] = {'\0'};
{
RwBlockDataArray[0].MxCmdBlockHeader.bytSlotNum = (BYTE)0;
RwBlockDataArray[0].MxCmdBlockHeader.wIOType = (WORD)IOTYPE_IR_WORD;
RwBlockDataArray[0].MxCmdBlockHeader.wFunction = (WORD)IOFUNC_IR_CH_VALUE;
RwBlockDataArray[0].MxCmdBlockHeader.wStartObj = wStartObj;
RwBlockDataArray[0].MxCmdBlockHeader.wTotalObj = wTotalObj;
}
//-----------------------
printf("MXIO_Read(%d)\n", ihConnection);
iRet = g_pMXIO_V3_2500->MXIO_Read(ihConnection, 1, RwBlockDataArray, ReadDataCallbackFunc1, NULL);
CheckErr(ihConnection, iRet, "MXIO_Read");
Sleep(1000);
}
//-----------------------------------------------------
if (0 != ihConnection)
{
iRet = g_pMXIO_V3_2500->MXIO_Disconnect(ihConnection);
CheckErr(ihConnection, iRet, "MXIO_Disconnect");
}
return 0;
}
//-----------------------------------------------------------------
UINT ThreadRead2( void * lParam )
{
int ihConnection = 0;
sprintf(io->szMACAddr, "%02X-%02X-%02X-%02X-%02X-%02X",
io->MxMACAddr.bytMAC[0],
io->MxMACAddr.bytMAC[1],
io->MxMACAddr.bytMAC[2],
io->MxMACAddr.bytMAC[3],
io->MxMACAddr.bytMAC[4],
io->MxMACAddr.bytMAC[5]);
printf("IP = %s, MAC = %s, Port=%d, Name=%s, Password=%s",
int iRet = g_pMXIO_V3_2500->MXIO_Connect(io->IPAddress, io->wPort, io->dwTimeout, &(io->MxMACAddr), io->AccountData, &ihConnection);
CheckErr(ihConnection, iRet, "MXIO_Connect");
printf("IP = %s, ihConnection = %d\r\n", io->IPAddress, ihConnection);
//-----------------------------------------------------
while(FALSE == io->bStop)
{
//Read
WORD wStartObj = 0, wTotalObj = 8;
CMXIO_V3_2500::MX_READ_BLOCK_DATA RwBlockDataArray[1] = {'\0'};
{
RwBlockDataArray[0].MxCmdBlockHeader.bytSlotNum = (BYTE)0;
RwBlockDataArray[0].MxCmdBlockHeader.wIOType = (WORD)IOTYPE_IR_WORD;
RwBlockDataArray[0].MxCmdBlockHeader.wFunction = (WORD)IOFUNC_IR_CH_VALUE;
RwBlockDataArray[0].MxCmdBlockHeader.wStartObj = wStartObj;
RwBlockDataArray[0].MxCmdBlockHeader.wTotalObj = wTotalObj;
}
//-----------------------
printf("MXIO_Read(%d)\n", ihConnection);
iRet = g_pMXIO_V3_2500->MXIO_Read(ihConnection, 1, RwBlockDataArray, ReadDataCallbackFunc2, NULL);
CheckErr(ihConnection, iRet, "MXIO_Read");
Sleep(1000);
}
//-----------------------------------------------------
if (0 != ihConnection)
{
iRet = g_pMXIO_V3_2500->MXIO_Disconnect(ihConnection);
CheckErr(ihConnection, iRet, "MXIO_Disconnect");
}
return 0;
}
void CheckErr ( int  ihConnection,
int  iRet,
char *  szFunctionName 
)
void CALLBACK ReadDataCallbackFunc1 ( WORD  wBlockQuantity,
int *  pRecvReadBlockData,
void *  pParam 
)
void CALLBACK ReadDataCallbackFunc2 ( WORD  wBlockQuantity,
int *  pRecvReadBlockData,
void *  pParam 
)

Variable Documentation

HMODULE g_hMXIO_V3_2500 = NULL
CMXIO_V3_2500* g_pMXIO_V3_2500 = NULL