void CANIntHandler(void) { u32 status = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); if(status == CAN_INT_INTID_STATUS) { status = CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); can_err_flag = 1; can_tx_flag = 0; } else if( status == 1 ) // Message receive { CANIntClear(CAN0_BASE, 1); can_rx_flag = 1; can_err_flag = 0; } else if( status == 2 ) // Message send { CANIntClear(CAN0_BASE, 2); can_tx_flag = 0; can_err_flag = 0; } else CANIntClear(CAN0_BASE, status); }
void CANIntHandler(void) { unsigned long status_flags; status_flags = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); if (status_flags == CAN_INT_INTID_STATUS) { status_flags = CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); // TODO: process the error? } else if (status_flags == 1) { // Wheel A sCANMessage.pui8MsgData = (uint8_t *)&wheel_a_data; CANMessageGet(CAN0_BASE, 1, &sCANMessage, 1); } else if (status_flags == 2) { // Wheel B sCANMessage.pui8MsgData = (uint8_t *)&wheel_b_data; CANMessageGet(CAN0_BASE, 2, &sCANMessage, 1); } else if (status_flags == 3) { // Engine sCANMessage.pui8MsgData = (uint8_t *)&engine_data; CANMessageGet(CAN0_BASE, 3, &sCANMessage, 1); } else if (status_flags == 4) { // Fuel sCANMessage.pui8MsgData = (uint8_t *)&fuel_data; CANMessageGet(CAN0_BASE, 4, &sCANMessage, 1); } else { // // Spurious interrupt handling can go here. // } }
//******************************************************************************* // CAN ISR //******************************************************************************* void CANIntHandler() { // Read the CAN interrupt status to find the cause of the interrupt CAN_status = CANIntStatus(CAN0_BASE,CAN_INT_STS_CAUSE); if(CAN_status == CAN_INT_INTID_STATUS) // controller status interrupt { CAN_status = CANStatusGet(CAN0_BASE,CAN_STS_CONTROL); // read back error bits it will // clear also the status interrupt if(CAN_status & (CAN_STATUS_BUS_OFF | CAN_STATUS_EWARN | CAN_STATUS_EPASS | CAN_STATUS_LEC_MASK)) { err_flag = 1; // set the error flag //UARTprintf("Device connected on the CAN bus?\n\r"); // hint for connection trouble } CANIntDisable(CAN0_BASE,CAN_INT_MASTER | CAN_INT_ERROR | CAN_INT_STATUS); //disable all CAN0 interrupts } else if(CAN_status == 1) // message object 1 interrupt { err_flag = 0; // clear any error flags CANIntClear(CAN0_BASE,1); // clear interrupt } else // should never happen { err_flag = 2 ; CANIntDisable(CAN0_BASE,CAN_INT_MASTER | CAN_INT_ERROR | CAN_INT_STATUS); //disable all CAN0 interrupts } }
void CANIntHandler(void) { u32 status = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); if(status == CAN_INT_INTID_STATUS) { status = MAP_CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); can_err_flag = 1; can_tx_flag = 0; } else if( status == CAN_MSG_OBJ_RX ) // Message receive { MAP_CANIntClear(CAN0_BASE, CAN_MSG_OBJ_RX); can_rx_flag = 1; can_err_flag = 0; } else if( status == CAN_MSG_OBJ_TX ) // Message send { MAP_CANIntClear(CAN0_BASE, CAN_MSG_OBJ_TX); can_tx_flag = 0; can_err_flag = 0; } else MAP_CANIntClear(CAN0_BASE, status); }
//***************************************************************************** // // The CAN controller interrupt handler. // //***************************************************************************** void CAN0_Handler(void){ uint8_t data[8]; uint32_t ulIntStatus, ulIDStatus; int i; tCANMsgObject xTempMsgObject; xTempMsgObject.pucMsgData = data; ulIntStatus = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); // cause? if(ulIntStatus & CAN_INT_INTID_STATUS){ // receive? ulIDStatus = CANStatusGet(CAN0_BASE, CAN_STS_NEWDAT); for(i = 0; i < 64; i++){ //test every bit of the mask if( (0x1 << i) & ulIDStatus){ // if active, get data CANMessageGet(CAN0_BASE, (i+1), &xTempMsgObject, true); if(xTempMsgObject.ulMsgID == RCV_ID){ if(CAN0_Fifo_Put(data[0])==0||CAN0_Fifo_Put(data[1])==0|| CAN0_Fifo_Put(data[2])==0||CAN0_Fifo_Put(data[3])==0|| CAN0_Fifo_Put(data[4])==0||CAN0_Fifo_Put(data[5])==0|| CAN0_Fifo_Put(data[6])==0||CAN0_Fifo_Put(data[7])==0){ PacketLost++;//increment the packet lost } MailFlag = true; // new mail } } } } CANIntClear(CAN0_BASE, ulIntStatus); // acknowledge }
//***************************************************************************** // // The CAN controller interrupt handler. // //***************************************************************************** void CANIntHandler(void) { unsigned long ulStatus; // // Find the cause of the interrupt, if it is a status interrupt then just // acknowledge the interrupt by reading the status register. // ulStatus = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); // // The first eight message objects make up the Transmit message FIFO. // if(ulStatus <= 8) { // // Increment the number of bytes transmitted. // g_sCAN.ulBytesTransmitted += 8; } // // The second eight message objects make up the Receive message FIFO. // else if((ulStatus > 8) && (ulStatus <= 16)) { // // Read the data out and acknowledge that it was read. // CANMessageGet(CAN0_BASE, ulStatus, &g_sCAN.MsgObjectRx, 1); // // Advance the read pointer. // g_sCAN.MsgObjectRx.pucMsgData += 8; // // Decrement the expected bytes remaining. // g_sCAN.ulBytesRemaining -= 8; } else { // // This was a status interrupt so read the current status to // clear the interrupt and return. // CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); } // // Acknowledge the CAN controller interrupt has been handled. // CANIntClear(CAN0_BASE, ulStatus); }
void CAN_ISR(void) { unsigned long ulStatus; ulStatus = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); switch(ulStatus) { case MSG_NUM_RX: // message received CANMessageGet(CAN0_BASE, MSG_NUM_RX, &g_MsgRx, /*clear int*/ 1); NetworkRxCallback(g_ulRxData); // call user function upon receiving a message break; default: // status or other interrupt: clear it without further action CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); CANIntClear(CAN0_BASE, ulStatus); } }
//***************************************************************************** // // The CAN controller interrupt handler. // //***************************************************************************** void CAN0_Handler(void){ uint8_t data[4]; uint32_t ulIntStatus, ulIDStatus; unsigned long temp; int i; tCANMsgObject xTempMsgObject; xTempMsgObject.pucMsgData = data; ulIntStatus = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); // cause? if(ulIntStatus & CAN_INT_INTID_STATUS){ // receive? ulIDStatus = CANStatusGet(CAN0_BASE, CAN_STS_NEWDAT); for(i = 0; i < 32; i++){ //test every bit of the mask if( (0x1 << i) & ulIDStatus){ // if active, get data CANMessageGet(CAN0_BASE, (i+1), &xTempMsgObject, true); if(xTempMsgObject.ulMsgID == Ping1_ID){ //temp = (data[0]<<24)&0xFF000000 + (data[1]<<16)&0x00FF0000 + (data[2]<<8)&0x0000FF00 + data[3]&0x000000FF; temp = (data[0]<<24) + (data[1]<<16) + (data[2]<<8) + data[3]; Mailbox = temp; }else if(xTempMsgObject.ulMsgID == Ping2_ID){ temp = (data[0]<<24) + (data[1]<<16) + (data[2]<<8) + data[3]; Mailbox2 = temp; }else if(xTempMsgObject.ulMsgID == Ping3_ID){ temp = (data[0]<<24) + (data[1]<<16) + (data[2]<<8) + data[3]; Mailbox3 = temp; }else if(xTempMsgObject.ulMsgID == Ping4_ID){ temp = (data[0]<<24) + (data[1]<<16) + (data[2]<<8) + data[3]; Mailbox4 = temp; }else if(xTempMsgObject.ulMsgID == Button1_ID){ button1Pressed = 1; //add thread that compensates for wall hit }else if(xTempMsgObject.ulMsgID == Button2_ID){ button2Pressed = 1; //add thread that compensates for wall hit }else if(xTempMsgObject.ulMsgID == IR_ID){ temp = (data[0]<<24) + (data[1]<<16) + (data[2]<<8) + data[3]; Mailbox5 = temp; } } } } CANIntClear(CAN0_BASE, ulIntStatus); // acknowledge }
void CAN0_Handler(void) { unsigned char data[8]; unsigned long ulIntStatus, ulIDStatus; CANmsgType rxMsg; int i; tCANMsgObject xTempMsgObject; xTempMsgObject.pucMsgData = data; // rxMsg.timestamp = OS_getTime(); //timestamp the CAN message ulIntStatus = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); if(ulIntStatus & CAN_INT_INTID_STATUS) { // receive? ulIDStatus = CANStatusGet(CAN0_BASE, CAN_STS_NEWDAT); for(i = 0; i < 32; i++) { //test every bit of the mask if( (0x1 << i) & ulIDStatus) { // if active, get data CANMessageGet(CAN0_BASE, (i+1), &xTempMsgObject, true); rxMsg.byte0 = data[0]; rxMsg.byte1 = data[1]; rxMsg.byte2 = data[2]; rxMsg.byte3 = data[3]; rxMsg.byte4 = data[4]; rxMsg.byte5 = data[5]; rxMsg.byte6 = data[6]; rxMsg.byte7 = data[7]; rxMsg.length = xTempMsgObject.ulMsgLen; rxMsg.ID = xTempMsgObject.ulMsgID; if(CAN_RX_FIFOFifo_Put(rxMsg) == CANFIFOFAIL); CAN_Data_lost++; OS_Signal(&CANmessagesReceived); break; } } } CANIntClear(CAN0_BASE, ulIntStatus); // acknowledge }
//***************************************************************************** // // The CAN controller interrupt handler. // //***************************************************************************** void CAN0_Handler(void){ unsigned char data[4]; unsigned long ulIntStatus, ulIDStatus; int i; tCANMsgObject xTempMsgObject; xTempMsgObject.pucMsgData = data; ulIntStatus = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); // cause? if(ulIntStatus & CAN_INT_INTID_STATUS){ // receive? ulIDStatus = CANStatusGet(CAN0_BASE, CAN_STS_NEWDAT); for(i = 0; i < 32; i++){ //test every bit of the mask if( (0x1 << i) & ulIDStatus){ // if active, get data CANMessageGet(CAN0_BASE, (i+1), &xTempMsgObject, true); if(xTempMsgObject.ulMsgID == RCV_ID){ RCVData[0] = data[0]; RCVData[1] = data[1]; RCVData[2] = data[2]; RCVData[3] = data[3]; MailFlag = true; // new mail } } } } CANIntClear(CAN0_BASE, ulIntStatus); // acknowledge }
// The CAN controller interrupt handler. void CANHandler(void) { unsigned long ulStatus; // // Find the cause of the interrupt, if it is a status interrupt then just // acknowledge the interrupt by reading the status register. // ulStatus = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); switch(ulStatus) { // This was a status interrupt so read the current status to clear the interrupt and return. default: { CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); return; } } // Acknowledge the CAN controller interrupt has been handled. CANIntClear(CAN0_BASE, ulStatus); }
//***************************************************************************** // // This function is the interrupt handler for the CAN peripheral. It checks // for the cause of the interrupt, and maintains a count of all messages that // have been transmitted. // //***************************************************************************** void CANIntHandler(void) { uint32_t ui32Status; // // Read the CAN interrupt status to find the cause of the interrupt // ui32Status = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); // // If the cause is a controller status interrupt, then get the status // if(ui32Status == CAN_INT_INTID_STATUS) { // // Read the controller status. This will return a field of status // error bits that can indicate various errors. Error processing // is not done in this example for simplicity. Refer to the // API documentation for details about the error status bits. // The act of reading this status will clear the interrupt. If the // CAN peripheral is not connected to a CAN bus with other CAN devices // present, then errors will occur and will be indicated in the // controller status. // ui32Status = CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); // // Set a flag to indicate some errors may have occurred. // g_bErrFlag = 1; } // // Check if the cause is message object 1, which is used for sending // message 1. // else if(ui32Status == 1) { // // Getting to this point means that the TX interrupt occurred on // message object 1, and the message TX is complete. Clear the // message object interrupt. // CANIntClear(CAN0_BASE, 1); // // Increment a counter to keep track of how many messages have been // sent. In a real application this could be used to set flags to // indicate when a message is sent. // g_ui32Msg1Count++; // // Since the message was sent, clear any error flags. // g_bErrFlag = 0; } // // Check if the cause is message object 2, which is used for sending // message 2. // else if(ui32Status == 2) { // // Getting to this point means that the TX interrupt occurred on // message object 2, and the message TX is complete. Clear the // message object interrupt. // CANIntClear(CAN0_BASE, 2); // // Increment a counter to keep track of how many messages have been // sent. In a real application this could be used to set flags to // indicate when a message is sent. // g_ui32Msg2Count++; // // Since the message was sent, clear any error flags. // g_bErrFlag = 0; } // // Check if the cause is message object 3, which is used for sending // messages 3 and 4. // else if(ui32Status == 3) { // // Getting to this point means that the TX interrupt occurred on // message object 3, and a message TX is complete. Clear the // message object interrupt. // CANIntClear(CAN0_BASE, 3); // // Increment a counter to keep track of how many messages have been // sent. In a real application this could be used to set flags to // indicate when a message is sent. // g_ui32Msg3Count++; // // Set the flag indicating that a message was sent using message // object 3. The program main loop uses this to know when to send // another message using message object 3. // g_bMsgObj3Sent = 1; // // Since the message was sent, clear any error flags. // g_bErrFlag = 0; } // // Otherwise, something unexpected caused the interrupt. This should // never happen. // else { // // Spurious interrupt handling can go here. // } }
//***************************************************************************** // // The CAN controller Interrupt handler. // //***************************************************************************** void CANHandler(void) { unsigned long ulStatus; // // Find the cause of the interrupt, if it is a status interrupt then just // acknowledge the interrupt by reading the status register. // ulStatus = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); switch(ulStatus) { // // Let the forground loop handle sending this, just set a flag to // indicate that the data should be sent. // case MSGOBJ_NUM_BUTTON: { // // Read the Button Message. // CANMessageGet(CAN0_BASE, MSGOBJ_NUM_BUTTON, &g_MsgObjectButton, 1); // // Only respond to buttons being release. // if(g_MsgObjectButton.pucMsgData[0] == EVENT_BUTTON_RELEASED) { // // Check if the up button was released. // if(g_MsgObjectButton.pucMsgData[1] == TARGET_BUTTON_UP) { // // Adjust the volume up by 10. // AudioVolumeUp(10); } // // Check if the down button was released. // if(g_MsgObjectButton.pucMsgData[1] == TARGET_BUTTON_DN) { // // Adjust the volume down by 10. // AudioVolumeDown(10); } } break; } // // When the LED message object interrupts, just clear the flag so that // more LED messages are allowed to transfer. // case MSGOBJ_NUM_LED: { g_ulFlags &= (~FLAG_LED_TX_PEND); break; } // // When the transmit data message object interrupts, clear the // flag so that more data can be trasferred. // case MSGOBJ_NUM_DATA_TX: { g_ulFlags &= (~FLAG_DATA_TX_PEND); break; } // // When a receive data message object interrupts, set the flag to // indicate that new data is ready. // case MSGOBJ_NUM_DATA_RX: { g_ulFlags |= FLAG_DATA_RECV; break; } // // This was a status interrupt so read the current status to // clear the interrupt and return. // default: { // // Read the controller status to acknowledge this interrupt. // CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); // // If there was a LED transmission pending, then stop it and // clear the flag. // if(g_ulFlags & FLAG_LED_TX_PEND) { // // Disable this message object until we retry it later. // CANMessageClear(CAN0_BASE, MSGOBJ_NUM_LED); // // Clear the transmit pending flag. // g_ulFlags &= (~FLAG_LED_TX_PEND); } // // If there was a Data transmission pending, then stop it and // clear the flag. // if(g_ulFlags & FLAG_DATA_TX_PEND) { // // Disable this message object until we retry it later. // CANMessageClear(CAN0_BASE, MSGOBJ_NUM_DATA_TX); // // Clear the transmit pending flag. // g_ulFlags &= (~FLAG_DATA_TX_PEND); } return; } } // // Acknowledge the CAN controller interrupt has been handled. // CANIntClear(CAN0_BASE, ulStatus); }
//***************************************************************************** // // CAN 0 Interrupt Handler. It checks for the cause of the interrupt, and // maintains a count of all messages that have been transmitted / received // //***************************************************************************** void CAN0IntHandler(void) { uint32_t ui32Status; // // Read the CAN interrupt status to find the cause of the interrupt // // CAN_INT_STS_CAUSE register values // 0x0000 = No Interrupt Pending // 0x0001-0x0020 = Number of message object that caused the interrupt // 0x8000 = Status interrupt // all other numbers are reserved and have no meaning in this system // ui32Status = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); // // If this was a status interrupt acknowledge it by reading the CAN // controller status register. // if(ui32Status == CAN_INT_INTID_STATUS) { // // Read the controller status. This will return a field of status // error bits that can indicate various errors. Refer to the // API documentation for details about the error status bits. // The act of reading this status will clear the interrupt. // ui32Status = CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); // // Add ERROR flags to list of current errors. To be handled // later, because it would take too much time here in the // interrupt. // g_ui32ErrFlag |= ui32Status; } // // Check if the cause is message object RXOBJECT, which we are using // for receiving messages. // else if(ui32Status == RXOBJECT) { // // Getting to this point means that the RX interrupt occurred on // message object RXOBJECT, and the message reception is complete. // Clear the message object interrupt. // CANIntClear(CAN0_BASE, RXOBJECT); // // Increment a counter to keep track of how many messages have been // received. In a real application this could be used to set flags to // indicate when a message is received. // g_ui32RXMsgCount++; // // Set flag to indicate received message is pending. // g_bRXFlag = true; // // Since a message was received, clear any error flags. // This is done because before the message is received it triggers // a Status Interrupt for RX complete. by clearing the flag here we // prevent unnecessary error handling from happeneing // g_ui32ErrFlag = 0; } // // Check if the cause is message object TXOBJECT, which we are using // for transmitting messages. // else if(ui32Status == TXOBJECT) { // // Getting to this point means that the TX interrupt occurred on // message object TXOBJECT, and the message reception is complete. // Clear the message object interrupt. // CANIntClear(CAN0_BASE, TXOBJECT); // // Increment a counter to keep track of how many messages have been // transmitted. In a real application this could be used to set // flags to indicate when a message is transmitted. // g_ui32TXMsgCount++; // // Since a message was transmitted, clear any error flags. // This is done because before the message is transmitted it triggers // a Status Interrupt for TX complete. by clearing the flag here we // prevent unnecessary error handling from happeneing // g_ui32ErrFlag = 0; } // // Otherwise, something unexpected caused the interrupt. This should // never happen. // else { // // Spurious interrupt handling can go here. // } }
//***************************************************************************** // // This function is the interrupt handler for the CAN peripheral. It checks // for the cause of the interrupt, and maintains a count of all messages that // have been transmitted. // //***************************************************************************** extern "C" void CAN0IntHandler(void) { unsigned long ulStatus; // Read the CAN interrupt status to find the cause of the interrupt ulStatus = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); // // If the cause is a controller status interrupt, then get the status // if (ulStatus == CAN_INT_INTID_STATUS) { // // Read the controller status. This will return a field of status // error bits that can indicate various errors. Error processing // is not done in this example for simplicity. Refer to the // API documentation for details about the error status bits. // The act of reading this status will clear the interrupt. If the // CAN peripheral is not connected to a CAN bus with other CAN devices // present, then errors will occur and will be indicated in the // controller status. // ulStatus = CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); if (ulStatus == CAN_STATUS_TXOK) { } else if (ulStatus == CAN_STATUS_RXOK) { } else /* CAN_STS_CONTROL - the main controller status CAN_STS_TXREQUEST - bit mask of objects pending transmissio CAN_STS_NEWDAT - bit mask of objects with new data CAN_STS_MSGVAL - bit mask of objects with valid configuration CAN_STATUS_BUS_OFF - controller is in bus-off condition CAN_STATUS_EWARN - an error counter has reached a limit of at least 96 CAN_STATUS_EPASS - CAN controller is in the error passive state CAN_STATUS_RXOK - a message was received successfully (independent of any mes-sage filtering). CAN_STATUS_TXOK - a message was successfully transmitted CAN_STATUS_LEC_MSK - mask of last error code bits (3 bits) CAN_STATUS_LEC_NONE - no error CAN_STATUS_LEC_STUFF - stuffing error detected CAN_STATUS_LEC_FORM - a format error occurred in the fixed format part of amessage CAN_STATUS_LEC_ACK - a transmitted message was not acknowledged CAN_STATUS_LEC_BIT1 - dominant level detected when trying to send in recessive mode CAN_STATUS_LEC_BIT0 - recessive level detected when trying to send in dominant mode CAN_STATUS_LEC_CRC - CRC error in received message */ can0._countErr++; } // // Check if the cause is message object 1, which what we are using for // sending messages. // else if (ulStatus < can0._tableIdx + 1 && ulStatus > 0) { uint32_t idx = ulStatus - 1; if (can0._table[idx].mode == CAN::RECV) { tCANMsgObject* msgObj = (can0._table[idx].msgObject); CANIntClear(CAN0_BASE, idx + 1); CANMessageGet(CAN0_BASE, idx + 1, msgObj, true); can0._countRxd++; CANListener* listener = can0._table[idx].listener; listener->recv(msgObj->ulMsgID, msgObj->ulMsgLen, msgObj->pucMsgData); CANMessageSet(CAN0_BASE, ulStatus, msgObj, MSG_OBJ_TYPE_RX); // CANMessageSet(CAN0_BASE, ulStatus, msgObj, MSG_OBJ_TYPE_TX); // reload } else if (can0._table[idx].mode == CAN::SEND) { CANListener* listener = can0._table[idx].listener; tCANMsgObject* msgObj = (can0._table[idx].msgObject); CANIntClear(CAN0_BASE, idx + 1); can0._countTxd++; listener->sendDone(msgObj->ulMsgID, E_OK); } } else { // // Spurious interrupt handling can go here. // CANIntClear(CAN0_BASE, ulStatus); } }
//***************************************************************************** // // This function is the interrupt handler for the CAN peripheral. It checks // for the cause of the interrupt, and maintains a count of all messages that // have been received. // //***************************************************************************** void CAN0_IRQHandler(void) { uint32_t ui32Status; // // Read the CAN interrupt status to find the cause of the interrupt // ui32Status = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); // // If the cause is a controller status interrupt, then get the status // if(ui32Status == CAN_INT_INTID_STATUS) { // // Read the controller status. This will return a field of status // error bits that can indicate various errors. Error processing // is not done in this example for simplicity. Refer to the // API documentation for details about the error status bits. // The act of reading this status will clear the interrupt. // ui32Status = CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); // // Set a flag to indicate some errors may have occurred. // g_bErrFlag = 1; } // // Check if the cause is message object 1. // else if(ui32Status == 1) { // // Getting to this point means that the RX interrupt occurred on // message object 1, and the message reception is complete. Clear the // message object interrupt. // CANIntClear(CAN0_BASE, 1); // // Increment a counter to keep track of how many messages have been // received. In a real application this could be used to set flags to // indicate when a message is received. // g_ui32MsgCount++; // // Set flag to indicate received message is pending for this message // object. // g_bRXFlag1 = 1; // // Since a message was received, clear any error flags. // g_bErrFlag = 0; } // // Check if the cause is message object 2. // else if(ui32Status == 2) { CANIntClear(CAN0_BASE, 2); g_ui32MsgCount++; g_bRXFlag2 = 1; g_bErrFlag = 0; } // // Check if the cause is message object 3. // else if(ui32Status == 3) { CANIntClear(CAN0_BASE, 3); g_ui32MsgCount++; g_bRXFlag3 = 1; g_bErrFlag = 0; } // // Otherwise, something unexpected caused the interrupt. This should // never happen. // else { // // Spurious interrupt handling can go here. // } }
//***************************************************************************** // // The CAN controller interrupt handler. // // /return None. // //***************************************************************************** void CANHandler(void) { unsigned long ulStatus; // // Find the cause of the interrupt, if it is a status interrupt then just // acknowledge the interrupt by reading the status register. // ulStatus = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE); switch(ulStatus) { // // Let the forground loop handle sending this, just set a flag to // indicate that the data should be sent. // case MSGOBJ_NUM_BUTTON: { // // Indicate a pending button transmission is complete. // g_ulFlags &= (~FLAG_BUTTON_PEND); break; } case MSGOBJ_NUM_LED: { // // Read the new LED level and let the foreground handle it. // CANMessageGet(CAN0_BASE, MSGOBJ_NUM_LED, &g_MsgObjectLED, 1); // // Limit the LED Level to MAX_LED_BRIGHTNESS. // if((g_ucLEDLevel & LED_FLASH_VALUE_MASK) > MAX_LED_BRIGHTNESS) { g_ucLEDLevel = MAX_LED_BRIGHTNESS | (g_ucLEDLevel & LED_FLASH_ONCE); } // // Indicate that the LED needs to be updated. // g_ulFlags |= FLAG_UPDATE_LED; break; } // // The data transmit message object has been sent successfully. // case MSGOBJ_NUM_DATA_TX: { // // Clear the data transmit pending flag. // g_ulFlags &= (~FLAG_DATA_TX_PEND); break; } // // The data receive message object has received some data. // case MSGOBJ_NUM_DATA_RX: { // // Indicate that the data message object has new data. // g_ulFlags |= FLAG_DATA_RECV; break; } // // This was a status interrupt so read the current status to // clear the interrupt and return. // default: { CANStatusGet(CAN0_BASE, CAN_STS_CONTROL); return; } } // // Acknowledge the CAN controller interrupt has been handled. // CANIntClear(CAN0_BASE, ulStatus); }