Esempio n. 1
0
int32_t initNTCAN(uint32_t baud,  uint32_t flags,
                  int32_t ID[], 	 int32_t net,
                  int32_t rxSize, int32_t rxTime,
                  int32_t txSize, int32_t txTime)
{
    NTCAN_HANDLE		handle;    	//
    NTCAN_RESULT		result;    	// Used for checking for error
    int32_t		i;       	  		// Index for multiple objects
    int32_t		timeout=0;   		// Current number of timeouts
    /* Open can */
    result = canOpen(net,flags,txSize,rxSize,   // Opens device
                     txTime,rxTime,&handle);
    if(errorCheck(CAN_OPEN,result) != 0)  			// Error check
    {
        return 0xFFFF;    // returns 1 if error
    }
//   printf("canOpen() success\n");
    /* Setting baudrate */
    result = canSetBaudrate(handle,baud);   		// sets baudrate
    if(errorCheck(CAN_SET_BAUDRATE,result) != 0) // Error check
    {
        return 0xFFFF;    // returns 1 if error
    }
    result = canGetBaudrate(handle,&baud);  		// Reads buadrate
//   printf("canSetBaudrate() success. Baudrate is %d\n",baud);
    /* Adding an ID */
    for(i=1; i<ID[0]; i++) {
        do  {
            result = canIdAdd(handle,ID[i]); 	// Adds ID to handle
            timeout++; 									// reapeat if Timeout
            if(timeout>MAX_TIMEOUT) {
                printf("Max timeout out reached, Aborting addID\n");
                return 0xFFFF;
            }  // return if repeated error
        } while( errorCheck(CAN_ID_ADD,result) == 2);
        if(errorCheck(CAN_ID_ADD,result) != 0) 	// error check
        {
            return 0xFFFF;
        }
//   printf("canIdAdd() successful\n");
    }
    printf("Initializing sucessfull\n");
    /* Flushing FIFO buffer */
    result = canIoctl(handle,NTCAN_IOCTL_FLUSH_RX_FIFO,NULL);
    if(errorCheck(CAN_IO_CTL,result) != 0) 		// flushing FIFO
    {
        return 0xFFFF;    // error check
    }
//   printf("System flushed, device ready to use\n");
    return handle; // returns handle for NTCAN device
}
int CESDDevice::setMessageId(unsigned long uiMessageId)
{
	int iRetVal = 0;
	m_iErrorState = 0;
	iRetVal = canIdAdd(m_hDevice, uiMessageId);
	if(iRetVal != NTCAN_SUCCESS)
	{
		warning("can add ID failed Errorcode: %d", iRetVal);
		getDeviceError(iRetVal);
		m_iErrorState = ERRID_DEV_INITERROR;
		return m_iErrorState;
	}
	return m_iErrorState;
}
Esempio n. 3
0
//-----------------------------------------------
CanESD::CanESD(int iIniBaudRate, int iNrNet)
{
	//initial values
	int net=1; /* logical net number (here: 0) */
	uint32_t mode=0; /* mode used for canOpen() */
	int32_t txqueuesize=100; /* size of transmit queue */
	int32_t rxqueuesize=100; /* size of receive queue */
	int32_t txtimeout=0; /* timeout for transmit operations in ms */
	int32_t rxtimeout=0; /* timeout for receive operations in ms */
	NTCAN_RESULT retvalue; /* return values of NTCAN API calls */
	//uint32_t baud=2; /* configured CAN baudrate (here: 500 kBit/s.) */
	CMSG cmsg[8]; /* can message buffer */
	int rtr=0; /* rtr bit */
	int32_t len; /* # of CAN messages */

	retvalue = canOpen(iNrNet, mode, txqueuesize, rxqueuesize, txtimeout, rxtimeout, &m_Handle);
	if (retvalue != NTCAN_SUCCESS)
	{
		LOGINFO("canOpen() failed: " << getErrorMessage(retvalue));
	}
	Sleep(300);
	retvalue = canSetBaudrate(m_Handle, getBaudRate(iIniBaudRate));
	if (retvalue != 0)
	{
		LOGINFO("canSetBaudrate() failed: " << getErrorMessage(retvalue)); 
		canClose(m_Handle);
	}
	else 
	{
		LOGINFO("Baudrate set to " << getBaudRate(iIniBaudRate));	
	}
	Sleep(300);
	
	//set Amtek Arm IDs
	int i;
	for(i=1; i < 2048; i++)
	{
		retvalue = canIdAdd(m_Handle, i);
		if (retvalue != NTCAN_SUCCESS)
		{
			LOGERROR("canIdAdd() failed: " << getErrorMessage(retvalue)); 
		}
	}

	Sleep(300);

	m_LastID = -1;
}
Esempio n. 4
0
/**
 * Add a group of CAN identifier to the handle, so it can be received.
 * The identifiers are generated by inverting the id and adding each value between 0 and 7
 * This is used for generating the answer commands by the RCS5000.
 * @param handle The handle to add the identifiers to.
 * @param id The command id sent to the RCS5000.
 * @return NTCAN_SUCESS if ok, or an error code.
 */
int CanESD::canIdAddGroup(HANDLE handle, int id)
{
	int result = NTCAN_SUCCESS;
	int i = 0;
	int iRes = 0;
	int cmd_id = invert(id);
	
	//m_Mutex.lock();
	for( i=0; i<8; ++i) {
		iRes = canIdAdd(m_Handle, cmd_id+i);
		//std::cout << "Adding CAN ID " << cmd_id+i << std::endl;
		if( iRes != NTCAN_SUCCESS ) {
			std::cout << "Adding CAN ID " << cmd_id+i << " failed with errorcode: " << iRes << " " << GetErrorStr(iRes) << std::endl;
			result = iRes;
		}
	}
	//m_Mutex.unlock();

	return result;
}
Esempio n. 5
0
//-----------------------------------------------
void CanESD::initIntern()
{	
	int ret=0;
/* Does this make any sense as the handle is opened somewhere later?!
	//m_Handle = 9;
	
	//m_Mutex.lock();

	//ret=canClose(m_Handle);

	if(ret == NTCAN_SUCCESS)
	{
		std::cout << "Can close ok ret = " << ret std::endl;
	}

	CAN_IF_STATUS *status;

	ret=canStatus(m_Handle,status);

	if(ret == NTCAN_SUCCESS)
	{
		std::cout << "Get status from can card ok ret = " << ret << std::endl;
	}
*/	
	ret = 0;
	int iCanNet = 1;
	//m_IniFile.GetKeyInt( "CanCtrl", "NetESD", &iCanNet, true);
	
	int iBaudrateVal = NTCAN_BAUD_250;
	//m_IniFile.GetKeyInt( "CanCtrl", "BaudrateVal", &iBaudrateVal, true);

	std::cout << "Initializing CAN network with id =" << iCanNet << ", baudrate=" << iBaudrateVal << std::endl;

	int iRet;
	if( m_bObjectMode )
		//iRet = canOpen(iCanNet, NTCAN_MODE_OBJECT, 10000, 10000, 0, 0, &m_Handle);
		iRet = canOpen(iCanNet, NTCAN_MODE_OBJECT, 10000, 10000, 1000, 0, &m_Handle);
	else
		//iRet = canOpen(iCanNet, 0, 10000, 10000, 0, 0, &m_Handle);
		iRet = canOpen(iCanNet, 0, 10000, 10000, 1000, 0, &m_Handle);
	sleep(0.3);

	if(iRet == NTCAN_SUCCESS)
		std::cout << "CanESD::CanESD(), init ok" << std::endl;
	else
		std::cout << "error in CANESD::receiveMsg: " << GetErrorStr(iRet) << std::endl;

/*	ret=canClose(m_Handle);
	if(ret == NTCAN_SUCCESS)
	{
		std::cout << "Can close ok ret = " << ret << std::endl;
		if( m_bObjectMode )
			iRet = canOpen(iCanNet, NTCAN_MODE_OBJECT, 10000, 10000, 0, 0, &m_Handle);
		else
			iRet = canOpen(iCanNet, 0, 10000, 10000, 0, 0, &m_Handle);
			Sleep(300);

		if(iRet == NTCAN_SUCCESS)
			std::cout << "CanESD::CanESD(), init ok" << ret << std::endl;
		else
			std::cout << "error in CANESD::receiveMsg: " << GetErrorStr(iRet) << std::endl;
	}
*/
	iRet = canSetBaudrate(m_Handle, iBaudrateVal);
	if(iRet == NTCAN_SUCCESS)
		std::cout << "CanESD::CanESD(), canSetBaudrate ok" << std::endl;
	else
		std::cout << "error in CANESD::receiveMsg: " << GetErrorStr(iRet) << std::endl;
	sleep(0.3);

	long lArg;
	iRet = canIoctl(m_Handle, NTCAN_IOCTL_FLUSH_RX_FIFO, NULL);
	//if( iRet == NTCAN_SUCCESS )
	//	std::cout << (int)(lArg) << " messages in CAN receive queue" << std::endl;

	// MMB/24.02.2006: Add all 11-bit identifiers as there is no loss in performance.
	for( int i=0; i<=0x7FF; ++i ) {
		iRet = canIdAdd( m_Handle, i );
		if(iRet != NTCAN_SUCCESS)
			std::cout << "error in CANESD::receiveMsg: " << GetErrorStr(iRet) << std::endl;
	}


	/*
	iRet = canIdAddGroup(m_Handle, 0x98);
	
	// for COB Arm
	iRet = canIdAdd(m_Handle, 0x100);
	iRet = canIdAdd(m_Handle, 0x101);
	iRet = canIdAdd(m_Handle, 0x200);
	iRet = canIdAdd(m_Handle, 0x201);
	iRet = canIdAdd(m_Handle, 0x300);
	iRet = canIdAdd(m_Handle, 0x301);
	iRet = canIdAdd(m_Handle, 0x400);
	iRet = canIdAdd(m_Handle, 0x401);
	iRet = canIdAdd(m_Handle, 0x500);
	iRet = canIdAdd(m_Handle, 0x501);
	iRet = canIdAdd(m_Handle, 0x600);
	iRet = canIdAdd(m_Handle, 0x601);
	
	// for CAN-Open Harmonica
	iRet = canIdAdd(m_Handle, 0x283);
	iRet = canIdAdd(m_Handle, 0x282);
	iRet = canIdAdd(m_Handle, 0x583);
	iRet = canIdAdd(m_Handle, 0x582);
	iRet = canIdAdd(m_Handle, 0x603);
	iRet = canIdAdd(m_Handle, 0x602);

	// for CAN-Open Harmonica and Cello Mimro
	iRet = canIdAdd(m_Handle, 0x18a);
	iRet = canIdAdd(m_Handle, 0x28a);
	iRet = canIdAdd(m_Handle, 0x194);
	iRet = canIdAdd(m_Handle, 0x294);
	iRet = canIdAdd(m_Handle, 0x19e);
	iRet = canIdAdd(m_Handle, 0x29e);
	
	// for RCS5000 arm
	iRet = canIdAdd(m_Handle, 0x111);
	iRet = canIdAdd(m_Handle, 0x112);
	iRet = canIdAdd(m_Handle, 0x113);
	iRet = canIdAdd(m_Handle, 0x114);
	iRet = canIdAdd(m_Handle, 0x115);
	iRet = canIdAdd(m_Handle, 0x116);
	iRet = canIdAdd(m_Handle, 0x788);
	iRet = canIdAdd(m_Handle, 0x789);
	iRet = canIdAdd(m_Handle, 0x78A);
	iRet = canIdAdd(m_Handle, 0x78B);
	iRet = canIdAdd(m_Handle, 0x78C);
	iRet = canIdAdd(m_Handle, 0x78D);
	iRet = canIdAdd(m_Handle, 0x78E);
	iRet = canIdAdd(m_Handle, 0x78F);

	iRet = canIdAddGroup(m_Handle, 0x00);
	iRet = canIdAddGroup(m_Handle, 0x08);
	iRet = canIdAddGroup(m_Handle, 0x10);
	iRet = canIdAddGroup(m_Handle, 0x18);
	iRet = canIdAddGroup(m_Handle, 0x20);
	iRet = canIdAddGroup(m_Handle, 0x28);
	iRet = canIdAddGroup(m_Handle, 0x30);
	iRet = canIdAddGroup(m_Handle, 0x38);
	iRet = canIdAddGroup(m_Handle, 0x40);
	iRet = canIdAddGroup(m_Handle, 0x48);
	iRet = canIdAddGroup(m_Handle, 0x50);
	iRet = canIdAddGroup(m_Handle, 0x58);
	iRet = canIdAddGroup(m_Handle, 0x60);
	iRet = canIdAddGroup(m_Handle, 0x68);
	iRet = canIdAddGroup(m_Handle, 0x98);

	// for Mimro drive ctrl
	iRet = canIdAdd(m_Handle, 0x123);
	*/

/*
	for(int i=0; i<2047; i++)
	{
		if (iRet != NTCAN_SUCCESS)
		{
			TRACE("canIdAdd: %x Error \n", i);
		}
	}
*/
	sleep(0.3);

	m_LastID = -1;

	//m_Mutex.unlock();
}
int CESDDevice::init(const char* acInitString)
{
	InitializeCriticalSection(&m_csDevice);
	int i, iRetVal = 0;
	int txTimeOut = 0;
	char* pcToken;
	char acString[128];
	if(m_bInitFlag)
	{
		warning("device already initialized");
		m_iErrorState = ERRID_DEV_ISINITIALIZED;
		return m_iErrorState;
	}
	m_iDeviceId = -1;
	m_iErrorState = 0;
	strncpy(m_acInitString,acInitString,128);
	strncpy(acString,acInitString,128);
	pcToken = strtok( acString, ":" );
	if( !pcToken )
	{	m_iErrorState = ERRID_DEV_BADINITSTRING;
		return m_iErrorState;
	}
	if( strcmp( pcToken, "ESD" ) != 0 )
	{	m_iErrorState = ERRID_DEV_BADINITSTRING;
		return m_iErrorState;
	}
	pcToken = strtok( NULL, "," );
	if( !pcToken )
	{	m_iErrorState = ERRID_DEV_BADINITSTRING;
		return m_iErrorState;
	}
	m_iDeviceId = atoi(pcToken);

	pcToken = strtok( NULL, "," );
	if( !pcToken )
	{	m_iErrorState = ERRID_DEV_BADINITSTRING;
		return m_iErrorState;
	}
	m_iBaudRate = atoi(pcToken);

#if defined(__LINUX__)
	m_uiTimeOut = 6;
#endif
#if defined (_WIN32)
	switch( m_iBaudRate )
	{
	case 125:
	case 250:
		m_uiTimeOut = 4;
		break;
	case 500:
		m_uiTimeOut = 3;
		break;
	case 1000:
		m_uiTimeOut = 2;
		break;
	default:
		m_uiTimeOut = 10;
		break;
	}
#endif

	try
	{
		iRetVal = canOpen(	
					m_iDeviceId,			// Net
					0,						// Mode
					m_uiQueueSize,			// TX Queue
					m_uiQueueSize,			// RX Queue
					m_uiTimeOut,			// Tx Timeout
					m_uiTimeOut,			// Rx Timeout
					&m_hDevice);
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can open failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}
		iRetVal = canOpen(	
					m_iDeviceId,			// Net
					0,						// Mode
					1,						// TX Queue
					1,						// RX Queue
					600,					// Tx Timeout
					100,					// Rx Timeout
					&m_hSyncDevice);
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can open failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}
	}
	catch(...)
	{
			warning("init ESD device failed no library found");
			m_iErrorState = ERRID_DEV_NOLIBRARY;
			return m_iErrorState;
	}

	for(i = 0; i <= m_iModuleCountMax; i++)
	{
		iRetVal = canIdAdd(m_hDevice, (MSGID_ACK + i));
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can add ID failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}
		iRetVal = canIdAdd(m_hDevice, (MSGID_STATE + i));
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can add ID failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}
	}

	for(i = 0; i <= MAX_MP55; i++ )
	{
		iRetVal = canIdAdd(m_hDevice, (MSGID_MP55_RECV + i));
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can add ID failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}

		iRetVal = canIdAdd(m_hDevice, (0x180 + i));
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can add ID failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}
		iRetVal = canIdAdd(m_hDevice, (0x600 + i));
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can add ID failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}
	}

	for(i = 0; i < MAX_SCHUNK; i++ )
	{
		iRetVal = canIdAdd(m_hDevice, (MSGID_SCHUNK_RECV + i));
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can add ID failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}
	}
	
	iRetVal = canIdAdd(m_hSyncDevice, MSGID_ALL);
	if(iRetVal != NTCAN_SUCCESS)
	{
		warning("can add ID failed Errorcode: %d", iRetVal);
		getDeviceError(iRetVal);
		m_iErrorState = ERRID_DEV_INITERROR;
		return m_iErrorState;
	}

	m_iErrorState = setBaudRate();
	if(m_iErrorState != 0)
		return m_iErrorState;

	m_iErrorState = clearReadQueue();
	if(m_iErrorState != 0)
		return m_iErrorState;

	if(m_iErrorState == 0)
		m_bInitFlag = true;

	updateModuleIdMap();
	return m_iErrorState;
}
int CESDDevice::reinit(unsigned char ucBaudRateId)
{
	int i, iRetVal = 0;
	m_iErrorState = 0;
	if(!m_bInitFlag)
	{
		warning("device not initialized");
		m_iErrorState = ERRID_DEV_NOTINITIALIZED;
		return m_iErrorState;
	}
	switch(ucBaudRateId)
	{
		case BAUDRATEID_MOD_CAN_125K:
			m_iBaudRate = 125;
			break;
		case BAUDRATEID_MOD_CAN_250K:
			m_iBaudRate = 250;
			break;
		case BAUDRATEID_MOD_CAN_500K:
			m_iBaudRate = 500;
			break;
		case BAUDRATEID_MOD_CAN_1000K:
			m_iBaudRate = 1000;
			break;
	}
	iRetVal = canClose(m_hDevice);
	if(iRetVal != NTCAN_SUCCESS)
	{
		warning("can close failed Errorcode: %d", iRetVal);
		getDeviceError(iRetVal);
		m_iErrorState = ERRID_DEV_EXITERROR;
	}
	iRetVal = canClose(m_hSyncDevice);
	if(iRetVal != NTCAN_SUCCESS)
	{
		warning("can close failed Errorcode: %d", iRetVal);
		getDeviceError(iRetVal);
		m_iErrorState = ERRID_DEV_EXITERROR;
	}
	m_bInitFlag = false;
	iRetVal = canOpen(	
				m_iDeviceId,			// Net
				0,						// Mode
				m_uiQueueSize,			// TX Queue
				m_uiQueueSize,			// RX Queue
				20*m_uiTimeOut,			// Tx Timeout
				m_uiTimeOut,			// Rx Timeout
				&m_hDevice);
	if(iRetVal != NTCAN_SUCCESS)
	{
		warning("can open failed Errorcode: %d", iRetVal);
		getDeviceError(iRetVal);
		m_iErrorState = ERRID_DEV_INITERROR;
		return m_iErrorState;
	}
	/*iRetVal = canOpen(	
				m_iDeviceId,			// Net
				0,						// Mode
				1,						// TX Queue
				1,						// RX Queue
				600,					// Tx Timeout
				100,					// Rx Timeout
				&m_hSyncDevice);
	if(iRetVal != NTCAN_SUCCESS)
	{
		warning("can open failed Errorcode: %d", iRetVal);
		getDeviceError(iRetVal);
		m_iErrorState = ERRID_DEV_INITERROR;
		return m_iErrorState;
	}*/

	m_iErrorState = setBaudRate();
	if(m_iErrorState != 0)
		return m_iErrorState;

	for(i = 0; i <= m_iModuleCountMax; i++)
	{
		iRetVal = canIdAdd(m_hDevice, (MSGID_ACK + i));
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can add ID failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}
		iRetVal = canIdAdd(m_hDevice, (MSGID_STATE + i));
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can add ID failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}
	}

	for(i = 0; i < MAX_MP55; i++ )
	{
		iRetVal = canIdAdd(m_hDevice, (MSGID_MP55_RECV + i));
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can add ID failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}

		iRetVal = canIdAdd(m_hDevice, (0x180 + i));
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can add ID failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}
	}

	for(i = 0; i < MAX_SCHUNK; i++ )
	{
		iRetVal = canIdAdd(m_hDevice, (MSGID_SCHUNK_RECV + i));
		if(iRetVal != NTCAN_SUCCESS)
		{
			warning("can add ID failed Errorcode: %d", iRetVal);
			getDeviceError(iRetVal);
			m_iErrorState = ERRID_DEV_INITERROR;
			return m_iErrorState;
		}
	}

	iRetVal = canIdAdd(m_hSyncDevice, MSGID_ALL);
	if(iRetVal != NTCAN_SUCCESS)
	{
		warning("can add ID failed Errorcode: %d", iRetVal);
		getDeviceError(iRetVal);
		m_iErrorState = ERRID_DEV_INITERROR;
		return m_iErrorState;
	}

	m_iErrorState = clearReadQueue();
	if(m_iErrorState != 0)
		return m_iErrorState;

	if(m_iErrorState == 0)
		m_bInitFlag = true;

	updateModuleIdMap();
	return m_iErrorState;
}