Vladimir86

August 10, 2017

Проблема решилась обновлением прошивки до версии 2.0

August 10, 2017

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

В 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);
	}
}
//-----------------------------------------------------------------

Sign In

Vladimir86

Posts

Joined

Last visited

Content Type

Profiles

Forums

Calendar

Posts posted by Vladimir86

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

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

Browse

Activity