Jump to content
Форум по продукции MOXA

Библиотека MXIO ioLogik 2500 для Windows

Vladimir86

Recommended Posts

Vladimir86 Новичок

Vladimir86

Posted
Posted
Добрый день! Использую пример из библиотеки "MXIO ioLogik 2500 для Windows". В исходном коде на с++ меняю только IP-адрес и запускаю. Пишет ошибку: "MXIO_V3_ERR_FUNCTION_NOT_SUPPORT". Что может быть?
 

post-11993-0-39006400-1502345830.jpg

 

В IOxpress показывает статус Lock, не знаю влияет это или нет. Прошивка версии 1.2.0.0.

 

Исходный код:

 

/*******************************************************************************
 * Copyright Moxa Inc.
 *
 *
 * Date          Author            Comment
 * 09/11/2015    Daniel Chang      Created.
 ******************************************************************************/
 
 /*!
    \file IOInfo.cpp
    \copyright Moxa Inc.
    \brief <b>\a Read \a IO \a Information</b>
    \date 09/11/2015
    \author Daniel Chang
    \version V1.0
    \details
*/

#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 WaitPressAnyKey();
void CheckErr(int ihConnection, int iRet, char *szFunctionName);
void PrtBlockErrorString(int iIndex, WORD wErrorCode);
void PrtChErrorString(int iIndex, BYTE bytErrorCode);

void CALLBACK ReadDataCallbackFunc(WORD wBlockQuantity, int *pRecvReadBlockData, void *pParam);;
void PrintReadChValue(int iIndex, CMXIO_V3_2500::MX_RECV_READ_BLOCK_DATA *pImp);
//-----------------------------------------------------------------
HMODULE g_hMXIO_V3_2500 = NULL;
CMXIO_V3_2500 *g_pMXIO_V3_2500 = NULL;

//-----------------------------------------------------------------
//! \include IOInfo.cpp
int main(int argc, char *argv[])
{
	char bytInputValue[64] = {'\0'};
	char szIP[] = "10.96.109.250";
	CMXIO_V3_2500::MX_MAC_ADDRESS MxMACAddr;
	memset(&MxMACAddr, 0, sizeof(MxMACAddr));
    char szMACAddr[18] = {'\0'};//"00-90-e8-00-00-41";
	DWORD dwTimeout = 3000;
	int ihConnection = 0;
	CMXIO_V3_2500::MX_ACCOUNT_DATA AccountData;
	sprintf(AccountData.szUserName,"%s", (char*)"admin");
	sprintf(AccountData.szPwd,"%s", (char*)"moxa");
	//-----------------------------------------------
	char IPAddress[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]\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_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)
	{
		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 ",
			IPAddress, szMACAddr, wPort, AccountData.szUserName, AccountData.szPwd);
		iRet = g_pMXIO_V3_2500->MXIO_Connect(IPAddress, wPort, dwTimeout, &MxMACAddr, &AccountData, &ihConnection);		
		CheckErr(ihConnection, iRet, "MXIO_Connect");
	}
	//-----------------------------------------------------
	if(MXIO_V3_OK == iRet)
	{		
		//Read
		//Note: wStartObj and wTotalObj of MX_CMD_BLOCK_HEADER must set to 0 in IOTYPE_SYS_IO_MODE Command.
		WORD wStartObj = 1, wTotalObj = 2; 
		CMXIO_V3_2500::MX_READ_BLOCK_DATA ReadBlockDataArray[1] = {'\0'};				
		{
			ReadBlockDataArray[0].MxCmdBlockHeader.bytSlotNum = (BYTE)0;
			ReadBlockDataArray[0].MxCmdBlockHeader.wIOType = (WORD)IOTYPE_SYS_IO_MODE;
			ReadBlockDataArray[0].MxCmdBlockHeader.wFunction = (WORD)IOFUNC_SYS_ALL_CH_MODE_DI;			
			ReadBlockDataArray[0].MxCmdBlockHeader.wStartObj = wStartObj;
			ReadBlockDataArray[0].MxCmdBlockHeader.wTotalObj = wTotalObj;
		}
		//-----------------------
		printf("MXIO_Read(%d)\n", ihConnection);
		iRet = g_pMXIO_V3_2500->MXIO_Read(ihConnection, 1, ReadBlockDataArray, ReadDataCallbackFunc, NULL);
		CheckErr(ihConnection, iRet, "MXIO_Read");
	}	
	
	//-----------------------------------------------------
	if (0 != ihConnection)
	{
		iRet = g_pMXIO_V3_2500->MXIO_Disconnect(ihConnection);
		CheckErr(ihConnection, iRet, "MXIO_Disconnect");
	}
	//-----------------------
	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);
	}
	WaitPressAnyKey();
	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;
}
//-----------------------------------------------------------------
void WaitPressAnyKey()
{
    system("pause");
}
//-----------------------------------------------------------------
//===========================================================================
void CheckErr(int ihConnection, int iRet, char *szFunctionName)
{
	char *szErrMsg = "MXIO_V3_OK";
	if (iRet != MXIO_V3_OK)
	{
		switch (iRet)
		{
		case MXIO_V3_ILLEGAL_FUNCTION:
			szErrMsg = "MXIO_V3_ILLEGAL_FUNCTION";
			break;
		case MXIO_V3_ILLEGAL_DATA_ADDRESS:
			szErrMsg = "MXIO_V3_ILLEGAL_DATA_ADDRESS";
			break;
		case MXIO_V3_ILLEGAL_DATA_VALUE:
			szErrMsg = "MXIO_V3_ILLEGAL_DATA_VALUE";
			break;
		case MXIO_V3_SLAVE_DEVICE_FAILURE:
			szErrMsg = "MXIO_V3_SLAVE_DEVICE_FAILURE";
			break;
		case MXIO_V3_SLAVE_DEVICE_BUSY:
			szErrMsg = "MXIO_V3_SLAVE_DEVICE_BUSY";
			break;
		case MXIO_V3_EIO_TIME_OUT:
			szErrMsg = "MXIO_V3_EIO_TIME_OUT";
			break;
		case MXIO_V3_EIO_INIT_SOCKETS_FAIL:
			szErrMsg = "MXIO_V3_EIO_INIT_SOCKETS_FAIL";
			break;
		case MXIO_V3_EIO_CREATING_SOCKET_ERROR:
			szErrMsg = "MXIO_V3_EIO_CREATING_SOCKET_ERROR";
			break;
		case MXIO_V3_EIO_RESPONSE_BAD:
			szErrMsg = "MXIO_V3_EIO_RESPONSE_BAD";
			break;
		case MXIO_V3_EIO_SOCKET_DISCONNECT:
			szErrMsg = "MXIO_V3_EIO_SOCKET_DISCONNECT";
			break;
		case MXIO_V3_PROTOCOL_TYPE_ERROR:
			szErrMsg = "MXIO_V3_PROTOCOL_TYPE_ERROR";
			break;
		case MXIO_V3_PRODUCT_NOT_SUPPORT:
			szErrMsg = "MXIO_V3_PRODUCT_NOT_SUPPORT";
			break;
		case MXIO_V3_HANDLE_ERROR:
		    szErrMsg = "MXIO_V3_HANDLE_ERROR";
		    break;
		case MXIO_V3_SLOT_OUT_OF_RANGE:
			szErrMsg = "MXIO_V3_SLOT_OUT_OF_RANGE";
			break;
		case MXIO_V3_CHANNEL_OUT_OF_RANGE:
			szErrMsg = "MXIO_V3_CHANNEL_OUT_OF_RANGE";
			break;
		case MXIO_V3_COIL_TYPE_ERROR:
			szErrMsg = "MXIO_V3_COIL_TYPE_ERROR";
			break;
		case MXIO_V3_REGISTER_TYPE_ERROR:
			szErrMsg = "MXIO_V3_REGISTER_TYPE_ERROR";
			break;
		case MXIO_V3_FUNCTION_NOT_SUPPORT:
		    szErrMsg = "MXIO_V3_FUNCTION_NOT_SUPPORT";
		    break;
		case MXIO_V3_OUTPUT_VALUE_OUT_OF_RANGE:
			szErrMsg = "MXIO_V3_OUTPUT_VALUE_OUT_OF_RANGE";
			break;
		case MXIO_V3_INPUT_VALUE_OUT_OF_RANGE:
			szErrMsg = "MXIO_V3_INPUT_VALUE_OUT_OF_RANGE";
			break;
		case MXIO_V3_EIO_PASSWORD_INCORRECT:
			szErrMsg = "MXIO_V3_EIO_PASSWORD_INCORRECT";
			break;
		case MXIO_V3_SLOT_NOT_EXIST:
			szErrMsg = "MXIO_V3_SLOT_NOT_EXIST";
			break;
		case MXIO_V3_FIRMWARE_NOT_SUPPORT:
			szErrMsg = "MXIO_V3_FIRMWARE_NOT_SUPPORT";
			break;
		case MXIO_V3_CREATE_MUTEX_FAIL:
			szErrMsg = "MXIO_V3_CREATE_MUTEX_FAIL";
			break;
		case MXIO_V3_ERR_ENUM_NET_INTERFACE_FAIL:
			szErrMsg = "MXIO_V3_ERR_ENUM_NET_INTERFACE_FAIL";
			break;
		case MXIO_V3_ERR_SELECT_NET_INTERFACE_FAIL:
			szErrMsg = "MXIO_V3_ERR_SELECT_NET_INTERFACE_FAIL";
			break;
		case MXIO_V3_ERR_FUNCTION_NOT_SUPPORT:
			szErrMsg = "MXIO_V3_ERR_FUNCTION_NOT_SUPPORT";
			break;
		case MXIO_V3_ERR_INVALID_HANDLE:
			szErrMsg = "MXIO_V3_ERR_INVALID_HANDLE";
			break;
		case MXIO_V3_ERR_BLOCK_QUANTITY:
			szErrMsg = "MXIO_V3_ERR_BLOCK_QUANTITY";
			break;
		case MXIO_V3_ERR_TOTAL_BLOCK_SIZE:
			szErrMsg = "MXIO_V3_ERR_TOTAL_BLOCK_SIZE";
			break;
		case MXIO_V3_ERR_REACH_MXIO_LIMIT_CONNECTION:
			szErrMsg = "MXIO_V3_ERR_REACH_MXIO_LIMIT_CONNECTION";
			break;
		case MXIO_V3_ERR_PARSE_XML_FAIL:
			szErrMsg = "MXIO_V3_ERR_PARSE_XML_FAIL";
			break;
		case MXIO_V3_ERR_ACCOUNT_VERIFY_FAIL:
			szErrMsg = "MXIO_V3_ERR_ACCOUNT_VERIFY_FAIL";
			break;
		case MXIO_V3_ERR_ACCOUNT_ACCESS_RIGHT:
			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);
}


//-----------------------------------------------------------------
typedef struct _CHANNEL_INFO{
	WORD wValue;
	char* szStr;
}CHANNEL_INFO;

void PrintReadChValue(int iIndex, CMXIO_V3_2500::MX_RECV_READ_BLOCK_DATA *pImp)
{
	CHANNEL_INFO wDIGITAL[] =
	{
		CHINFO_DI_DI,        "CHINFO_DI_DI",
		CHINFO_DI_COUNTER,   "CHINFO_DI_COUNTER",
		CHINFO_DO_DO,        "CHINFO_DO_DO",
		CHINFO_DO_PULSE,     "CHINFO_DO_PULSE",
		CHINFO_DIO_DI,       "CHINFO_DIO_DI",
		CHINFO_DIO_COUNTER,  "CHINFO_DIO_COUNTER",
		CHINFO_DIO_DO,       "CHINFO_DIO_DO",
		CHINFO_DIO_PULSE,    "CHINFO_DIO_PULSE",
		CHINFO_RELAY_RELAY,  "CHINFO_RELAY_RELAY",
		CHINFO_RELAY_PULSE,  "CHINFO_RELAY_PULSE",
	};

	CHANNEL_INFO wANALOG_AI[] =
	{
		CHINFO_AI_150mV,            "CHINFO_AI_150mV",
		CHINFO_AI_500mV,            "CHINFO_AI_500mV",
		CHINFO_AI_5V,               "CHINFO_AI_5V",
		CHINFO_AI_10V,              "CHINFO_AI_10V",
		CHINFO_AI_0_20mA,           "CHINFO_AI_0_20mA",
		CHINFO_AI_4_20mA,           "CHINFO_AI_4_20mA",
		CHINFO_AI_0_10V,            "CHINFO_AI_0_10V",
		CHINFO_AI_4_20mA_BurnOut,   "CHINFO_AI_4_20mA_BurnOut",
		CHINFO_AI_DISABLED,         "CHINFO_AI_DISABLED",
	};

	CHANNEL_INFO wANALOG_AO[] =
	{
		CHINFO_AO_4_20mA,   "CHINFO_AO_4_20mA",
		CHINFO_AO_0_10V,    "CHINFO_AO_0_10V",
		CHINFO_AO_DISABLED, "CHINFO_AO_DISABLED",
	};

	CHANNEL_INFO wANALOG_TC[] =
	{
		CHINFO_TC_J_TYPE,       "CHINFO_TC_J_TYPE",
		CHINFO_TC_K_TYPE,       "CHINFO_TC_K_TYPE",
		CHINFO_TC_T_TYPE,       "CHINFO_TC_T_TYPE",
		CHINFO_TC_E_TYPE,       "CHINFO_TC_E_TYPE",
		CHINFO_TC_R_TYPE,       "CHINFO_TC_R_TYPE",
		CHINFO_TC_S_TYPE,       "CHINFO_TC_S_TYPE",
		CHINFO_TC_B_TYPE,       "CHINFO_TC_B_TYPE",
		CHINFO_TC_N_TYPE,       "CHINFO_TC_N_TYPE",
		CHINFO_TC_VOL_78126,    "CHINFO_TC_VOL_78126",
		CHINFO_TC_VOL_39062,    "CHINFO_TC_VOL_39062",
		CHINFO_TC_VOL_19532,    "CHINFO_TC_VOL_19532",
		CHINFO_TC_DISABLED,     "CHINFO_TC_DISABLED",
	};

	CHANNEL_INFO wANALOG_RTD[] =
	{
		CHINFO_RTD_PT100,    "CHINFO_RTD_PT100",
		CHINFO_RTD_PT200,    "CHINFO_RTD_PT200",
		CHINFO_RTD_PT500,    "CHINFO_RTD_PT500",
		CHINFO_RTD_PT1000,   "CHINFO_RTD_PT1000",
		CHINFO_RTD_JPT100,   "CHINFO_RTD_JPT100",
		CHINFO_RTD_JPT200,   "CHINFO_RTD_JPT200",
		CHINFO_RTD_JPT500,   "CHINFO_RTD_JPT500",
		CHINFO_RTD_JPT1000,  "CHINFO_RTD_JPT1000",
		CHINFO_RTD_NI100,    "CHINFO_RTD_NI100",
		CHINFO_RTD_NI200,    "CHINFO_RTD_NI200",
		CHINFO_RTD_NI500,    "CHINFO_RTD_NI500",
		CHINFO_RTD_NI1000,   "CHINFO_RTD_NI1000",
		CHINFO_RTD_RES_310,  "CHINFO_RTD_RES_310",
		CHINFO_RTD_RES_620,  "CHINFO_RTD_RES_620",
		CHINFO_RTD_RES_1250, "CHINFO_RTD_RES_1250",
		CHINFO_RTD_RES_2200, "CHINFO_RTD_RES_2200",
		CHINFO_RTD_PT50,     "CHINFO_RTD_PT50",
		CHINFO_RTD_NI120,    "CHINFO_RTD_NI120",
		CHINFO_RTD_DISABLED, "CHINFO_RTD_DISABLED",
	};

	CHANNEL_INFO wANALOG_SERIAL[] =
	{
		CHINFO_SERIALTAG_BYTE,   "CHINFO_SERIALTAG_BYTE",
		CHINFO_SERIALTAG_WORD,	 "CHINFO_SERIALTAG_CHANNEL_WORD",
		CHINFO_SERIALTAG_DWORD,  "CHINFO_SERIALTAG_DCHANNEL_DWORD",
		CHINFO_SERIALTAG_INT,    "CHINFO_SERIALTAG_INT",
		CHINFO_SERIALTAG_FLOAT,  "CHINFO_SERIALTAG_FLOAT",
	};

	WORD wChInfo = (WORD)pImp->pRwChannelData[iIndex].unValue.wValue;
	for(int i=0; i < sizeof(wDIGITAL)/sizeof(wDIGITAL[0]); i++)
		if(wDIGITAL[i].wValue == wChInfo)
			printf("[%d] = %s\n", iIndex, wDIGITAL[i].szStr);
	for(int i=0; i < sizeof(wANALOG_AI)/sizeof(wANALOG_AI[0]); i++)
		if(wANALOG_AI[i].wValue == wChInfo)
			printf("[%d] = %s\n", iIndex, wANALOG_AI[i].szStr);
	for(int i=0; i < sizeof(wANALOG_AO)/sizeof(wANALOG_AO[0]); i++)
		if(wANALOG_AO[i].wValue == wChInfo)
			printf("[%d] = %s\n", iIndex, wANALOG_AO[i].szStr);
	for(int i=0; i < sizeof(wANALOG_TC)/sizeof(wANALOG_TC[0]); i++)
		if(wANALOG_TC[i].wValue == wChInfo)
			printf("[%d] = %s\n", iIndex, wANALOG_TC[i].szStr);
	for(int i=0; i < sizeof(wANALOG_RTD)/sizeof(wANALOG_RTD[0]); i++)
		if(wANALOG_RTD[i].wValue == wChInfo)
			printf("[%d] = %s\n", iIndex, wANALOG_RTD[i].szStr);
	for(int i=0; i < sizeof(wANALOG_SERIAL)/sizeof(wANALOG_SERIAL[0]); i++)
		if(wANALOG_SERIAL[i].wValue == wChInfo)
			printf("[%d] = %s\n", iIndex, wANALOG_SERIAL[i].szStr);
}

//-----------------------------------------------------------------
void CALLBACK ReadDataCallbackFunc(WORD wBlockQuantity, int *pRecvReadBlockData, void *pParam)
{
	CMXIO_V3_2500::MX_RECV_READ_BLOCK_DATA *pReadImp = (CMXIO_V3_2500::MX_RECV_READ_BLOCK_DATA *)pRecvReadBlockData;
	if (pReadImp)
	{
		if (MXIO_V3_BLOCK_OK == pReadImp->MxRecvBlockHeader.wResult) //
		{
			printf("Read Block[%d] Success:\n", (wBlockQuantity-1));
			for (int i = 0; i < pReadImp->MxRecvBlockHeader.wTotalObj; i++)
			{
				if (MXIO_V3_CH_OK == pReadImp->pRwChannelData[i].bytErrorCode)
					PrintReadChValue(i, pReadImp);
				else
					PrtChErrorString(i, pReadImp->pRwChannelData[i].bytErrorCode);
			}
		}
		else
			PrtBlockErrorString((wBlockQuantity - 1), pReadImp->MxRecvBlockHeader.wResult);
	}
}
//-----------------------------------------------------------------
 

 

 

post-11993-0-39006400-1502345830_thumb.jpg

Link to comment

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
Go to topic listing
×
×
  • Create New...