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

Read Float Value, e.g. AI Scaled, Burnout, Min. or Max. Value More...

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

Classes

struct  _FUNC_CHINFO
 

Typedefs

typedef struct _FUNC_CHINFO FUNC_CHINFO
 
typedef struct _FUNC_CHINFOpFUNC_CHINFO
 

Functions

int MXCreateLibrary (HMODULE *phMXIO_V3_4500, CMXIO_V3_4500 **pMXIO_V3_4500, char *szLibName)
 
int MXDestroyLibrary (HMODULE hMXIO_V3_4500, CMXIO_V3_4500 **pMXIO_V3_4500)
 
void WaitPressAnyKey ()
 
void CheckErr (int ihConnection, int iRet, char *szFunctionName)
 
void PrtStrErrorString (WORD wErrorCode, char *szName)
 
void PrtStrChErrorString (BYTE bytErrorCode, char *pszName)
 
void CALLBACK ReadStrDataCallbackFunc (int *pRecvReadBlockData, void *pParam)
 
void PrintStrReadValue (int iIndex, CMXIO_V3_4500::MX_RECV_STR_READ_DATA *pImp)
 
int main (int argc, char *argv[])
 
BOOL PrintStrCHInfoStr (int iIndex, CMXIO_V3_4500::MX_RECV_STR_READ_DATA *pImp)
 
void PrtChErrorString (int iIndex, BYTE bytErrorCode)
 

Variables

HMODULE g_hMXIO_V3_4500 = NULL
 
CMXIO_V3_4500g_pMXIO_V3_4500 = NULL
 
FUNC_CHINFO FuncInfo []
 

Detailed Description

Read Float Value, e.g. AI Scaled, Burnout, Min. or Max. Value

Date
02/25/2019
Author
Daniel Chang
Version
V1.0

Typedef Documentation

typedef struct _FUNC_CHINFO FUNC_CHINFO
typedef struct _FUNC_CHINFO * pFUNC_CHINFO

Function Documentation

int MXCreateLibrary ( HMODULE *  phMXIO_V3_4500,
CMXIO_V3_4500 **  pMXIO_V3_4500,
char *  szLibName 
)
int MXDestroyLibrary ( HMODULE  hMXIO_V3_4500,
CMXIO_V3_4500 **  pMXIO_V3_4500 
)
void WaitPressAnyKey ( )
void CheckErr ( int  ihConnection,
int  iRet,
char *  szFunctionName 
)
void PrtStrErrorString ( WORD  wErrorCode,
char *  szName 
)
void PrtStrChErrorString ( BYTE  bytErrorCode,
char *  pszName 
)
void CALLBACK ReadStrDataCallbackFunc ( int *  pRecvReadBlockData,
void *  pParam 
)
void PrintStrReadValue ( int  iIndex,
CMXIO_V3_4500::MX_RECV_STR_READ_DATA pImp 
)
int main ( int  argc,
char *  argv[] 
)
/*******************************************************************************
* Copyright Moxa Inc.
*
*
* Date Author Comment
* 02/25/2019 Daniel Chang Created.
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "../../../../include/MXIO_V3_4500.h"
//-----------------------------------------------------------------
int MXCreateLibrary(HMODULE *phMXIO_V3_4500, CMXIO_V3_4500 **pMXIO_V3_4500, char *szLibName);
int MXDestroyLibrary(HMODULE hMXIO_V3_4500, CMXIO_V3_4500 **pMXIO_V3_4500);
void CheckErr(int ihConnection, int iRet, char *szFunctionName);
void PrtStrErrorString(WORD wErrorCode, char *szName);
void PrtStrChErrorString(BYTE bytErrorCode, char* pszName);
void CALLBACK ReadStrDataCallbackFunc(int *pRecvReadBlockData, void *pParam);
//-----------------------------------------------------------------
HMODULE g_hMXIO_V3_4500 = NULL;
CMXIO_V3_4500 *g_pMXIO_V3_4500 = NULL;
//-----------------------------------------------------------------
int main(int argc, char *argv[])
{
char bytInputValue[64] = {'\0'};
char szIP[] = "192.168.127.253";
memset(&MxMACAddr, 0, sizeof(MxMACAddr));
char szMACAddr[18] = {'\0'};//"00-90-e8-00-00-41";
DWORD dwTimeout = 3000;
int ihConnection = 0;
sprintf(AccountData.szUserName,"%s", (char*)"admin");
sprintf(AccountData.szPwd,"%s", (char*)"moxa");
//-----------------------------------------------
char IPAddress[16] = {'\0'};
char szTempBuf[16] = {'\0'};
sprintf(IPAddress, "%s", szIP);
if (argc <= 1)
{
printf("Cmd Format: [IP Address] [Timeout] [TCP Port]\n");
strcpy(IPAddress, szIP);
}
//
if (argc > 1)
sprintf(IPAddress, "%s", argv[1]);
if (argc > 2)
dwTimeout = atoi(argv[2]);
if (argc > 3)
wPort = atoi(argv[3]);
printf("Input IP Address=%s, TimeOut=%d, TCP Port=%d\n", IPAddress, dwTimeout, wPort);
//-----------------------
int iRet = MXIO_V3_OK;
iRet = MXCreateLibrary(&g_hMXIO_V3_4500, &g_pMXIO_V3_4500, "MXIO_4500.dll");
printf("MXCreateLibrary() g_pMXIO_V3_4500=0x%p return %d(0x%X)\n", g_pMXIO_V3_4500, iRet, iRet);
//-----------------------
if (MXIO_V3_OK == iRet)
{
iRet = g_pMXIO_V3_4500->MXIO_Init();
printf("MXIO_Init() return %d(0x%X)\n", iRet, iRet);
}
//-----------------------
if (MXIO_V3_OK == iRet)
{
sprintf(szMACAddr, "%02X-%02X-%02X-%02X-%02X-%02X",
MxMACAddr.bytMAC[0],
MxMACAddr.bytMAC[1],
MxMACAddr.bytMAC[2],
MxMACAddr.bytMAC[3],
MxMACAddr.bytMAC[4],
MxMACAddr.bytMAC[5]);
printf("IP = %s, MAC = %s, Port=%d, Name=%s, Password=%s\n",
IPAddress, szMACAddr, wPort, AccountData.szUserName, AccountData.szPwd);
iRet = g_pMXIO_V3_4500->MXIO_Connect(IPAddress, wPort, dwTimeout, &MxMACAddr, &AccountData, &ihConnection);
CheckErr(ihConnection, iRet, (char*)"MXIO_Connect");
}
//-----------------------------------------------------
if(MXIO_V3_OK == iRet)
{
//Read
ReadStrBlockData.wTotalQuantity = 1;
ReadStrBlockData.pMxStrCmd = new CMXIO_V3_4500::MX_STR_CMD[1];
ReadStrBlockData.pMxStrCmd[0].wIOType = (WORD)(IOTYPE_IR_FLOAT);
ReadStrBlockData.pMxStrCmd[0].wFunction = (WORD)(IOFUNC_IR_CH_VALUE);
ReadStrBlockData.pMxStrCmd[0].szDevChName = (char*)"ioThinx_4510@FIR-00";
printf("MXIO_Read(%d)\n", ihConnection);
iRet = g_pMXIO_V3_4500->MXIO_Read(ihConnection, &ReadStrBlockData, ReadStrDataCallbackFunc, NULL);
CheckErr(ihConnection, iRet, (char *)"MXIO_Read");
//Free memory
delete [] ReadStrBlockData.pMxStrCmd;
}
//-----------------------------------------------------
if (0 != ihConnection)
{
iRet = g_pMXIO_V3_4500->MXIO_Disconnect(ihConnection);
CheckErr(ihConnection, iRet, (char*)"MXIO_Disconnect");
}
//-----------------------
if (NULL != g_hMXIO_V3_4500)
{
iRet = g_pMXIO_V3_4500->MXIO_Exit();
printf("MXIO_Exit() return %d(0x%X)\n", iRet, iRet);
iRet = MXDestroyLibrary(g_hMXIO_V3_4500, &g_pMXIO_V3_4500);
printf("MXDestroyLibrary() return %d(0x%X)\n", iRet, iRet);
}
return 0;
}
//-----------------------------------------------------------------
int MXCreateLibrary(HMODULE *phMXIO_V3_4500, CMXIO_V3_4500 **pMXIO_V3_4500, char *szLibName)
{
*phMXIO_V3_4500 = LoadLibrary(szLibName);
if (NULL == *phMXIO_V3_4500)
return (GetLastError());
PFNCREATEMXIO_V3_4500 pfnCreateMXIO_V3_4500 = (PFNCREATEMXIO_V3_4500)GetProcAddress(*phMXIO_V3_4500, "CreateMXIO_4500");
if (NULL == pfnCreateMXIO_V3_4500)
return (-1);
*pMXIO_V3_4500 = pfnCreateMXIO_V3_4500();
return 0;
}
//-----------------------------------------------------------------
int MXDestroyLibrary(HMODULE hMXIO_V3_4500, CMXIO_V3_4500 **pMXIO_V3_4500)
{
PFNDESTROYMXIO_V3_4500 pfnDestroyMXIO_V3_4500 = (PFNDESTROYMXIO_V3_4500)GetProcAddress(hMXIO_V3_4500, "DestroyMXIO_4500");
if (NULL == pfnDestroyMXIO_V3_4500)
return (GetLastError());
pfnDestroyMXIO_V3_4500(*pMXIO_V3_4500);
FreeLibrary(hMXIO_V3_4500);
*pMXIO_V3_4500 = NULL;
return 0;
}
//-----------------------------------------------------------------
{
system("pause");
}
//-----------------------------------------------------------------
//===========================================================================
void CheckErr(int ihConnection, int iRet, char *szFunctionName)
{
char *szErrMsg = (char *)"MXIO_V3_OK";
if (iRet != MXIO_V3_OK)
{
switch (iRet)
{
szErrMsg = (char *)"MXIO_V3_ILLEGAL_FUNCTION";
break;
szErrMsg = (char *)"MXIO_V3_ILLEGAL_DATA_ADDRESS";
break;
szErrMsg = (char *)"MXIO_V3_ILLEGAL_DATA_VALUE";
break;
szErrMsg = (char *)"MXIO_V3_SLAVE_DEVICE_FAILURE";
break;
szErrMsg = (char *)"MXIO_V3_SLAVE_DEVICE_BUSY";
break;
szErrMsg = (char *)"MXIO_V3_EIO_TIME_OUT";
break;
szErrMsg = (char *)"MXIO_V3_EIO_INIT_SOCKETS_FAIL";
break;
szErrMsg = (char *)"MXIO_V3_EIO_CREATING_SOCKET_ERROR";
break;
szErrMsg = (char *)"MXIO_V3_EIO_RESPONSE_BAD";
break;
szErrMsg = (char *)"MXIO_V3_EIO_SOCKET_DISCONNECT";
break;
szErrMsg = (char *)"MXIO_V3_PROTOCOL_TYPE_ERROR";
break;
szErrMsg = (char *)"MXIO_V3_PRODUCT_NOT_SUPPORT";
break;
szErrMsg = (char*)"MXIO_V3_HANDLE_ERROR";
break;
szErrMsg = (char *)"MXIO_V3_SLOT_OUT_OF_RANGE";
break;
szErrMsg = (char *)"MXIO_V3_CHANNEL_OUT_OF_RANGE";
break;
szErrMsg = (char *)"MXIO_V3_COIL_TYPE_ERROR";
break;
szErrMsg = (char *)"MXIO_V3_REGISTER_TYPE_ERROR";
break;
szErrMsg = (char*)"MXIO_V3_FUNCTION_NOT_SUPPORT";
break;
szErrMsg = (char *)"MXIO_V3_OUTPUT_VALUE_OUT_OF_RANGE";
break;
szErrMsg = (char *)"MXIO_V3_INPUT_VALUE_OUT_OF_RANGE";
break;
szErrMsg = (char *)"MXIO_V3_EIO_PASSWORD_INCORRECT";
break;
szErrMsg = (char *)"MXIO_V3_SLOT_NOT_EXIST";
break;
szErrMsg = (char *)"MXIO_V3_FIRMWARE_NOT_SUPPORT";
break;
szErrMsg = (char *)"MXIO_V3_CREATE_MUTEX_FAIL";
break;
szErrMsg = (char *)"MXIO_V3_ERR_ENUM_NET_INTERFACE_FAIL";
break;
szErrMsg = (char *)"MXIO_V3_ERR_SELECT_NET_INTERFACE_FAIL";
break;
szErrMsg = (char *)"MXIO_V3_ERR_FUNCTION_NOT_SUPPORT";
break;
szErrMsg = (char *)"MXIO_V3_ERR_INVALID_HANDLE";
break;
szErrMsg = (char *)"MXIO_V3_ERR_BLOCK_QUANTITY";
break;
szErrMsg = (char *)"MXIO_V3_ERR_TOTAL_BLOCK_SIZE";
break;
szErrMsg = (char *)"MXIO_V3_ERR_REACH_MXIO_LIMIT_CONNECTION";
break;
szErrMsg = (char *)"MXIO_V3_ERR_PARSE_XML_FAIL";
break;
szErrMsg = (char *)"MXIO_V3_ERR_ACCOUNT_VERIFY_FAIL";
break;
szErrMsg = (char *)"MXIO_V3_ERR_ACCOUNT_ACCESS_RIGHT";
break;
szErrMsg = (char *)"MXIO_V3_PARSING_DEVICE_NAME_ERROR";
break;
szErrMsg = (char *)"MXIO_V3_PARSING_CHANNEL_NAME_ERROR";
break;
szErrMsg = (char *)"MXIO_V3_PARSING_INPUT_NAME_ERROR";
break;
default:
szErrMsg = (char *)"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);
}
}
//-----------------------------------------------------------------
typedef struct _FUNC_CHINFO
{
char *szChInfo;
//
FUNC_CHINFO FuncInfo[] =
{
{IOTYPE_DI, IOFUNC_DI_CH_MODE, CHINFO_DI_DI, (char *)"CHINFO_DI_DI"},
{IOTYPE_DI, IOFUNC_DI_CH_MODE, CHINFO_DI_COUNTER, (char *)"CHINFO_DI_COUNTER"},
{IOTYPE_DO, IOFUNC_DO_CH_MODE, CHINFO_DO_DO, (char *)"CHINFO_DO_DO"},
{IOTYPE_DO, IOFUNC_DO_CH_MODE, CHINFO_DO_PULSE, (char *)"CHINFO_DO_PULSE"},
{IOTYPE_AI, IOFUNC_AI_CH_MODE, CHINFO_AI_DISABLED, (char *)"CHINFO_AI_DISABLED"},
{IOTYPE_AI, IOFUNC_AI_CH_MODE, CHINFO_AI_150mV, (char *)"CHINFO_AI_150mV"},
{IOTYPE_AI, IOFUNC_AI_CH_MODE, CHINFO_AI_500mV, (char *)"CHINFO_AI_500mV"},
{IOTYPE_AI, IOFUNC_AI_CH_MODE, CHINFO_AI_5V, (char *)"CHINFO_AI_5V"},
{IOTYPE_AI, IOFUNC_AI_CH_MODE, CHINFO_AI_10V, (char *)"CHINFO_AI_10V"},
{IOTYPE_AI, IOFUNC_AI_CH_MODE, CHINFO_AI_0_20mA, (char *)"CHINFO_AI_0_20mA"},
{IOTYPE_AI, IOFUNC_AI_CH_MODE, CHINFO_AI_4_20mA, (char *)"CHINFO_AI_4_20mA"},
{IOTYPE_AI, IOFUNC_AI_CH_MODE, CHINFO_AI_0_10V, (char *)"CHINFO_AI_0_10V"},
{IOTYPE_AI, IOFUNC_AI_CH_MODE, CHINFO_AI_4_20mA_BurnOut, (char *)"CHINFO_AI_4_20mA_BurnOut"},
{IOTYPE_AI, IOFUNC_AI_CH_MODE, CHINFO_AI_M10V_10V, (char *)"CHINFO_AI_-10V_10V"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_DISABLED, (char *)"CHINFO_TC_DISABLED"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_J_TYPE, (char *)"CHINFO_TC_J_TYPE"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_K_TYPE, (char *)"CHINFO_TC_K_TYPE"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_T_TYPE, (char *)"CHINFO_TC_T_TYPE"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_E_TYPE, (char *)"CHINFO_TC_E_TYPE"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_R_TYPE, (char *)"CHINFO_TC_R_TYPE"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_S_TYPE, (char *)"CHINFO_TC_S_TYPE"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_B_TYPE, (char *)"CHINFO_TC_B_TYPE"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_N_TYPE, (char *)"CHINFO_TC_N_TYPE"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_VOL_78126, (char *)"CHINFO_TC_VOL_78126"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_VOL_39062, (char *)"CHINFO_TC_VOL_39062"},
{IOTYPE_TC, IOFUNC_TC_CH_MODE, CHINFO_TC_VOL_19532, (char *)"CHINFO_TC_VOL_19532"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_DISABLED, (char *)"CHINFO_RTD_DISABLED"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_PT100, (char *)"CHINFO_RTD_PT100"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_PT200, (char *)"CHINFO_RTD_PT200"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_PT500, (char *)"CHINFO_RTD_PT500"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_PT1000, (char *)"CHINFO_RTD_PT1000"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_JPT100, (char *)"CHINFO_RTD_JPT100"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_JPT200, (char *)"CHINFO_RTD_JPT200"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_JPT500, (char *)"CHINFO_RTD_JPT500"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_JPT1000, (char *)"CHINFO_RTD_JPT1000"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_NI100, (char *)"CHINFO_RTD_NI100"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_NI200, (char *)"CHINFO_RTD_NI200"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_NI500, (char *)"CHINFO_RTD_NI500"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_NI1000, (char *)"CHINFO_RTD_NI1000"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_RES_310, (char *)"CHINFO_RTD_RES_310"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_RES_620, (char *)"CHINFO_RTD_RES_620"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_RES_1250, (char *)"CHINFO_RTD_RES_1250"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_RES_2200, (char *)"CHINFO_RTD_RES_2200"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_PT50, (char *)"CHINFO_RTD_PT50"},
{IOTYPE_RTD, IOFUNC_RTD_CH_MODE, CHINFO_RTD_NI120, (char *)"CHINFO_RTD_NI120"},
};
//-----------------------------------------------------------------
{
BOOL bIsModeCmd = FALSE;
WORD wIOType = pImp->MxRecvStrCmd->wIOType;
WORD wFunc = pImp->MxRecvStrCmd->wFunction;
BYTE bytSlotNum = pImp->MxRecvStrCmd->bytSlotNum;
for (int i = 0; i < sizeof(FuncInfo) / sizeof(FuncInfo[0]); i++)
{
if (FuncInfo[i].wIOType == wIOType)
{
if (FuncInfo[i].wFunc == wFunc)
{
bIsModeCmd = TRUE;
if (FuncInfo[i].dwChInfo == pImp->pRwChannelData[iIndex].unValue.dwValue)
{
printf("%s Mode = %d(0x%X): %s\r\n", pImp->MxRecvStrCmd->szDevChName,
FuncInfo[i].szChInfo);
return bIsModeCmd;
}
}
}
}
if (bIsModeCmd)
{
printf("ch[%d] Mode = %d(0x%X) Undefined!! *****\r\n", iIndex,
}
return bIsModeCmd;
}
//-----------------------------------------------------------------
{
if (PrintStrCHInfoStr(iIndex, pImp))
return;
BYTE bytDataType = pImp->pRwChannelData[iIndex].bytDataType;
BYTE bytSlotNum = pImp->MxRecvStrCmd->bytSlotNum;
char* pszDevChName = pImp->MxRecvStrCmd->szDevChName;
if ((DATA_TYPE_BYTE == bytDataType) || (DATA_TYPE_WORD == bytDataType))
printf("%s = %d(0x%02X)\n", pszDevChName, pImp->pRwChannelData[iIndex].unValue.dwValue, pImp->pRwChannelData[iIndex].unValue.dwValue);
else if ((DATA_TYPE_DWORD == bytDataType) || (DATA_TYPE_INT == bytDataType))
printf("%s = %d(0x%04X)\n", pszDevChName, pImp->pRwChannelData[iIndex].unValue.dwValue, pImp->pRwChannelData[iIndex].unValue.dwValue);
else if (DATA_TYPE_FLOAT == bytDataType)
printf("%s = %.3f\n", pszDevChName, pImp->pRwChannelData[iIndex].unValue.fValue);
else if (DATA_TYPE_STRING == bytDataType)
printf("%s = %s\n", pszDevChName, pImp->pRwChannelData[iIndex].unValue.szValue);
else if (DATA_TYPE_DATE == bytDataType)
{
printf("%s = %d/%d/%d\n", pszDevChName,
pImp->pRwChannelData[iIndex].unValue.MxDate.Day);
}
else if (DATA_TYPE_TIME == bytDataType)
{
printf("%s = %d:%d:%d\n", pszDevChName,
pImp->pRwChannelData[iIndex].unValue.MxTime.Sec);
}
else if (DATA_TYPE_UNKNOWN == bytDataType)
printf("%s = data type return DATA_TYPE_UNKNOWN\n", pszDevChName);
else
printf("%s = not defined data type = %d\n", pszDevChName, bytDataType);
}
//-----------------------------------------------------------------
void PrtStrErrorString(WORD wErrorCode, char *szName)
{
if (MXIO_V3_BLOCK_ERR_SIZE == wErrorCode)
printf("[%s] = BLOCK_ERR_SIZE\n", szName);
else if (MXIO_V3_BLOCK_ERR_TYPE == wErrorCode)
printf("[%s] = BLOCK_ERR_TYPE\n", szName);
else if (MXIO_V3_BLOCK_ERR_SUBTYPE == wErrorCode)
printf("[%s] = BLOCK_ERR_SUBTYPE\n", szName);
else if (MXIO_V3_BLOCK_ERR_FUNCTION == wErrorCode)
printf("[%s] = BLOCK_ERR_FUNCTION\n", szName);
else if (MXIO_V3_BLOCK_ERR_SLOT == wErrorCode)
printf("[%s] = BLOCK_ERR_SLOT\n", szName);
else if (MXIO_V3_BLOCK_ERR_START_OBJ == wErrorCode)
printf("[%s] = BLOCK_ERR_START_CHANNEL\n", szName);
else if (MXIO_V3_BLOCK_ERR_TOTAL_OBJ == wErrorCode)
printf("[%s] = BLOCK_ERR_TOTAL_CHANNEL\n", szName);
else
printf("[%s] = Not defined error code= %d\n", szName, 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);
}
//-----------------------------------------------------------------
void CALLBACK ReadStrDataCallbackFunc(int *pRecvReadBlockData, void *pParam)
{
if (pReadImp)
{
BYTE bytSlotNum = pReadImp->MxRecvStrCmd->bytSlotNum;
WORD wTotalQuantity = pReadImp->wTotalQuantity;
if (MXIO_V3_BLOCK_OK == pReadImp->MxRecvStrCmd->wResult) //
{
printf("Read by string [%s] Success:\n", pReadImp->MxRecvStrCmd->szDevChName);
for (int i = 0; i < pReadImp->wTotalQuantity; i++)
{
PrintStrReadValue(i, pReadImp);
else
}
}
else
}
}
//-----------------------------------------------------------------
void PrtStrChErrorString(BYTE bytErrorCode, char* pszName)
{
if (MXIO_V3_CH_OK == bytErrorCode)
printf("%s = SUCCESS\n", pszName);
else if (MXIO_V3_CH_ERR_LOCKED == bytErrorCode)
printf("%s = ERROR_LOCKED\n", pszName);
else if (MXIO_V3_CH_ERR_READ_ONLY == bytErrorCode)
printf("%s = ERROR_READ_ONLY\n", pszName);
else if (MXIO_V3_CH_ERR_SUBTYPE == bytErrorCode)
printf("%s = ERROR_SUBTYPE\n", pszName);
else if (MXIO_V3_CH_ERR_DATA_TYPE == bytErrorCode)
printf("%s = ERROR_DATA_TYPE\n", pszName);
else if (MXIO_V3_CH_ERR_DATA == bytErrorCode)
printf("%s = ERROR_DATA\n", pszName);
else if (MXIO_V3_CH_ERR_DISABLE == bytErrorCode)
printf("%s = ERROR_DISABLE\n", pszName);
else if (MXIO_V3_CH_ERR_BOOLEAN_ONLY == bytErrorCode)
printf("%s = ERROR_BOOLEAN_ONLY\n", pszName);
else if (MXIO_V3_CH_ERR_WRITE_FAIL == bytErrorCode)
printf("%s = MXIO_V3_CH_ERR_WRITE_FAIL\n", pszName);
else if (MXIO_V3_CH_ERR_PARSING_STR_FAIL == bytErrorCode)
printf("%s = MXIO_V3_CH_ERR_PARSING_STR_FAIL\n", pszName);
else
printf("%s = Not defined error code(%d)\n", pszName, bytErrorCode);
}
//-----------------------------------------------------------------
BOOL PrintStrCHInfoStr ( int  iIndex,
CMXIO_V3_4500::MX_RECV_STR_READ_DATA pImp 
)
void PrtChErrorString ( int  iIndex,
BYTE  bytErrorCode 
)

Variable Documentation

HMODULE g_hMXIO_V3_4500 = NULL
CMXIO_V3_4500* g_pMXIO_V3_4500 = NULL
FUNC_CHINFO FuncInfo[]