test_can_sja1000.c

cpc-1631的BSP包for VxWorks操作系统

}

 void canclose()
{
	releaseNode(0);
	if(fd_can)
	{		
		close(fd_can);
		fd_can = 0;
	}
}
 
 /* 检查can收到的字符串的条数*/
int canchk(void)
{
#if 0
	FILE *fd = NULL;
	char buffer[10] = {0};
	char buffer1[40] = {0};
	int len = 0;
	int count = 0;

	fd = fopen("can_result.txt", "r");
	
	if(fd<0)
	{
		printf("open can_result.txt error!\r\n");
		return ERROR;
	}

	while(!feof(fd))
	{		
		memset(buffer, 0 ,sizeof(buffer));
		fread(buffer, strlen(can_send), 1, fd);
		if(0 == memcmp(buffer, can_send, strlen(buffer)))
		{
			count++;
		}
	}

	if(count < 1 )
	{
	    printf("The number of received strings is 0 \r\n");
	    return ERROR;
	}
	else
	{
	    printf("The number of received strings is %d\r\n", count-1);
	}
	fclose(fd);
#endif	
	printf("Id = 0x%x and extFlag is %d \n", id0[0], extFlag0[0]); 

	printf("The number of received strings is %d\r\n", recvLen);
	
	return OK;
}

 /**************************************************************************
 * 
 * stopNode - Bring CAN controller offline
 * 
 * RETURNS: OK
 *
 * ERRNO:   N/A
 *
 */
 int stopNode
     (
     int ctrlr
     )
 {
     struct WNCAN_Device *pDev;
     
     if(ctrlr == 1)
         pDev = pDev1; 
     else
         pDev = pDev0; 
     
     /*Check if pDev is valid*/     
     if(NULL==pDev){
         logMsg("Call setupNode first \n",0,0,0,0,0,0);
         return ERROR;
     }
     
     CAN_Stop(pDev);
     
     return OK;
 }
 
 /**************************************************************************
 * 
 * startNode - Bring CAN controller online
 * 
 * RETURNS: OK
 *
 * ERRNO:   N/A
 *
 */
 int startNode(int ctrlr)
 {
     struct WNCAN_Device *pDev;
     
     if(ctrlr == 1)
         pDev = pDev1;  
     else
         pDev = pDev0;
     
     /*Check if pDev is valid*/     
     if(NULL==pDev){
         logMsg("Call setupNode first \n",0,0,0,0,0,0);
         return ERROR;
     }
     
     CAN_Start(pDev);
     
     return OK;
 }
 
 /**************************************************************************
 * 
 * releaseNode - Release device pointer to CAN controller
 *
 * This function does the following:
 *
 * 1. Abort all pending transmissions
 * 2. Bring CAN controller offline
 * 3. Disable and Free all channels
 * 4. Disable interrupts
 * 5. Give up device pointer
 * 
 * RETURNS: OK
 *
 * ERRNO:   N/A
 *
 */
 int releaseNode
     (
     int ctrlr
     )
 {
     
     int i;
     
     if(ctrlr == 1)   
     {
        /*Check if pDev1 is valid*/     
        if(NULL==pDev1){
            logMsg("Call setupNode first \n",0,0,0,0,0,0);
            return ERROR;
        } 
		
        CAN_TxAbort(pDev1);
        
        CAN_Stop(pDev1);
        
        for(i=0;i<pDev1->pCtrl->numChn;i++)
        {
            CAN_DisableChannel(pDev1, i);
            CAN_FreeChannel(pDev1, i);
        }
        
        CAN_DisableInt(pDev1);
        
        CAN_Close(pDev1);
        
        pDev1=NULL;
    }
    else
    {
        
        /*Check if pDev0 is valid*/     
        if(NULL==pDev0){
            logMsg("Call setupNode first \n",0,0,0,0,0,0);
            return ERROR;
        } 
        
        CAN_TxAbort(pDev0);
        
        CAN_Stop(pDev0);
        
        for(i=0;i<pDev0->pCtrl->numChn;i++)
        {
            CAN_DisableChannel(pDev0, i);
            CAN_FreeChannel(pDev0, i);
        }
        
        CAN_DisableInt(pDev0);
        
        CAN_Close(pDev0);
        
        pDev0=NULL;
        
    }
    
     can_open = 0;
	 
     return OK;
     
 }
 
 /**************************************************************************
 * 
 * statusNode - Print bus Status to stdout
 *
 * RETURNS: OK 
 * 
 * ERRNO:   N/A
 *
 */
 int statusNode
     (
     int ctrlr
     )
 {
     struct WNCAN_Device *pDev;
     WNCAN_BusStatus busStatus;
     long globalMask;
     long localMask;
     
     if(ctrlr == 1) 
         pDev = pDev1;
     else
         pDev = pDev0;  
     
     /*Check if pDev is valid*/     
     if(NULL==pDev){
         logMsg("Call setupNode first \n",0,0,0,0,0,0);
         return ERROR;
     }

     busStatus = CAN_GetBusStatus(pDev);     
     
     if(busStatus == WNCAN_BUS_OFF)  
         logMsg("Bus status is BUS OFF \n",0,0,0,0,0,0);
     else if(busStatus == WNCAN_BUS_WARN)    
	 logMsg("Bus status is BUS WARNING, more than 96 transmit errors have \
                 occured \n",0,0,0,0,0,0);
     else 
         logMsg("Bus status is BUS OK, error active  \n",0,0,0,0,0,0);
     
     globalMask = CAN_GetGlobalRxFilter(pDev, 0);
     
     logMsg("Global Filter is %x \n",globalMask,0,0,0,0,0);
     
     localMask = CAN_GetLocalMsgFilter(pDev, 14, 1);
     
     logMsg("Local Filter is %x \n",localMask,0,0,0,0,0);
     
     return OK;
     
 }
 
 /**************************************************************************
 * 
 * printRxMsg - Print all the received message identifiers and data to stdout
 *
 * Received message ids are recorded in an array by the ISR call back function.
 *
 * RETURNS: OK 
 *
 * ERRNO:   N/A
 *
 */
 int printRxMsg
     (
     int ctrlr
     )
 {   
     int i;
     
     if(ctrlr == 1)   
     {
         
         for(i=0;i<ArrayIndex1;i++)   
         {
             logMsg("Id[%d] = %x and extFlag is %d \n", i, id1[i], extFlag1[i],0,0,0);   
         }
     }
     else
     {
         for(i=0;i<ArrayIndex0;i++)   
         {
             logMsg("Id[%d] = %x and extFlag is %d \n", i, id0[i], extFlag0[i],0,0,0);   
         }
     }
     
     return OK; 
 }
 
 /**************************************************************************
 *
 * ISR call back function for ctrlr 0
 *
 */
 void test_isr0(struct WNCAN_Device *pDev, WNCAN_IntType intStatus, UCHAR channelNum)
 {
     
     WNCAN_BusError busErr;
	 int i=0;
	 int read=ERROR;
	 int fd=0;
	 int bytes_write=0;
     
     if(intStatus == WNCAN_INT_WAKE_UP)  
         flagAwake0++;
     
     if(intStatus == WNCAN_INT_TXCLR)
     {
         CAN_DisableChannel(pDev, channelNum);
         CAN_FreeChannel(pDev, channelNum);
                 
     }
     
     if(intStatus == WNCAN_INT_RX)
     {
         id0[0] = CAN_ReadID(pDev, channelNum, &extFlag0[0]);        
         /*logMsg("Id[%d] = %x and extFlag is %d \n", ArrayIndex0, id0[ArrayIndex0], extFlag0[ArrayIndex0],0,0,0);   */
	read = CAN_ReadData(pDev,channelNum,recData,8,FALSE);

	if(read == OK)
	{
		if(0==memcmp(recData,can_send,8))
		{
			recvLen++;
	         (ArrayIndex0 >= 99)?ArrayIndex0=0:ArrayIndex0 ++;

		}
/*	
		for(i=0;i<8;i++)
		{
		logMsg("channelNum=%d, data[%d]= %x  \n",channelNum,i,recData[i],0,0,0);   
		}
*/
	}
	else
	{
		logMsg("CAN_ReadData error\n",0,0,0,0,0,0);
	}

         
     }
     
     if(intStatus == WNCAN_INT_ERROR)
     {
         logMsg("CAN bus error occurred: ",0,0,0,0,0,0);    
         busErr = CAN_GetBusError(pDev);   
         switch(busErr)
         {
         case WNCAN_ERR_BIT:
             logMsg("WNCAN_ERR_BIT \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_ACK:
             logMsg("WNCAN_ERR_ACK \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_CRC:
             logMsg("WNCAN_ERR_CRC \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_FORM:
             logMsg("WNCAN_ERR_FORM \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_STUFF:
             logMsg("WNCAN_ERR_STUFF \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_NONE:
             logMsg("WNCAN_ERR_NONE \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_UNKNOWN:
         default:
             logMsg("WNCAN_ERR_UNKNOWN \n",0,0,0,0,0,0);
             break;     
             
         }  
         
         
     }

     
     if(intStatus == WNCAN_INT_BUS_OFF)
     	{
	 	logMsg("WNCAN_INT_BUS_OFF...\n",0,0,0,0,0,0);
         releaseNode(0);
     	}
     
     
     
 }
 
 /**************************************************************************
 *
 * ISR call back function for ctrlr 1
 *
 */
 void test_isr1(struct WNCAN_Device *pDev, WNCAN_IntType intStatus, UCHAR channelNum)
 {
     
     WNCAN_BusError busErr;
     
     if(intStatus == WNCAN_INT_WAKE_UP)  
         flagAwake1++;
     
     if(intStatus == WNCAN_INT_TX)
     {
         CAN_DisableChannel(pDev, channelNum);
         CAN_FreeChannel(pDev, channelNum);         
     }
     
     if(intStatus == WNCAN_INT_RX)
     {
         id1[ArrayIndex1] = CAN_ReadID(pDev, channelNum, &extFlag1[ArrayIndex1]);        
         
         (ArrayIndex1 >= 99)?ArrayIndex1=0:ArrayIndex1 ++;
         
     }
     
     if(intStatus == WNCAN_INT_ERROR)
     {
         logMsg("CAN bus error occurred: ",0,0,0,0,0,0);    
         busErr = CAN_GetBusError(pDev);   
         
         switch(busErr)
         {
         case WNCAN_ERR_BIT:
             logMsg("WNCAN_ERR_BIT \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_ACK:
             logMsg("WNCAN_ERR_ACK \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_CRC:
             logMsg("WNCAN_ERR_CRC \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_FORM:
             logMsg("WNCAN_ERR_FORM \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_STUFF:
             logMsg("WNCAN_ERR_STUFF \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_NONE:
             logMsg("WNCAN_ERR_NONE \n",0,0,0,0,0,0);
             break;
         case WNCAN_ERR_UNKNOWN:
         default:
             logMsg("WNCAN_ERR_UNKNOWN \n",0,0,0,0,0,0);
             break;     
             
         }  
         
     }
     
     
     if(intStatus == WNCAN_INT_BUS_OFF)
         releaseNode(1);
     
     
 }