//*******************************************************
// This is a WinAVR/GCC compiler 8 bit AT90CANxxx family AVR CAN Rx test program. It
// provides a framework to Rx all CAN traffic and add your own debug output. See the
// comments in main() for adding your own debug output code.
//
// This is intended as working CAN driver code to test new CAN hardware. It requires
// another CAN node to Tx CAN traffic to this AVR CAN node.
//
// This code requires a very high availibility for the ISR (CANIT_vect) interrupt.
// If your code adds anything to degrade this availibility, the results may not be
// reliable.
#include <avr/interrupt.h>
#include <util/atomic.h>
// Place your other CAN chip includes here.
#define AT90CAN_MOBS 15
#define MOB_DIS_CMD ((0 << CONMOB1) | (0 << CONMOB0))
#define MOB_RX_CMD ((1 << CONMOB1) | (0 << CONMOB0))
#define MOB_TX_CMD ((0 << CONMOB1) | (1 << CONMOB0))
#define MOB_IDE_11F (0 << IDE)
#define MOB_IDE_29F (1 << IDE)
#define MOB_DLC_FIELD ((1 << DLC3) | (1 << DLC2) | (1 << DLC1) | (1 << DLC0))
#define MOB_MAX_DLC ((1 << DLC3) | (0 << DLC2) | (0 << DLC1) | (0 << DLC0))
#define MOB_DLC_LIMIT(dlc) (((dlc) > MOB_MAX_DLC) ? MOB_MAX_DLC : (dlc))
#define MOB1_RX_DLC_DEFAULT 8
volatile uint8_t Can_status; // Used by the CAN ISR and main().
//*******************************************************
// Initialize the CAN hardware and the global status value. The user needs to provide the
// correct baud rate setup (see the data sheet).
//
void can_init (void) {
uint8_t mob; // Temporary MOb register set selection number value.
CANGCON = (1 << SWRES); // Reset the CAN controller hardware and general CAN registers.
Can_status = 0; // Global variable starting value for each CAN initialization.
// All MObs must be initialized because MObs have no reset initial value.
for (mob = 0; mob < AT90CAN_MOBS; mob++) {
CANPAGE = (mob << MOBNB0); // Set the MOb page number for each MOb 0 to 14 (15 MObs total).
CANCDMOB = MOB_DIS_CMD; // Set each MOb configuration to disabled *CRITICAL*.
CANSTMOB = 0; // Clear all the MOb interrupt/polling flags *CRITICAL*.
}
//****
// This is a randomly selected CAN Baud setting, you need to put your real values based on
// CLKio here. See the CAN baud examples and the Baud Rate Prescaler errata in the ATMEL
// data sheet.
//****
CANBT1 = 0x0e;
CANBT2 = 0x0c;
CANBT3 = 0x37;
// CANTCON was cleared by the SWRES (see the data sheet).
CANGIE = (1 << ENIT) | (1 << ENRX) | (1 << ENERR) | (1 << ENERG);
CANIE2 = (1 << IEMOB0); // MOb 0 Interrupt Enabled,
// CANIE1 was cleared by the SWRES (see the data sheet).
// CANGIT was cleared by the SWRES (see the data sheet).
CANGCON = (1 << ENASTB) ; // Enable the CAN.
}
//*******************************************************
// Setup MOb 0 to Rx all CAN traffic. This is any 11 or 29 bit IDE format, any CANIDT ID
// value and any Data or Remote frame RTRTAG CAN traffic. Since this MOb will Rx both 11
// bit and 29 bit ID formats, 29 bit format is used to setup this MOb. This example is
// written to use a 29 bit UL constant to demonstrate setting 29 bit values, even though
// this is not needed for zero values (a uint32_t variable could replace the UL constant).
//
void mob_init (void) {
CANPAGE = (0 << MOBNB0); // Select MOb 0, AINC = 0, INDEX2:0 = 0.
// Put an initial 0x00000000 ID into CANIDT (see the mask below).
CANIDT1 = (uint8_t) (0x00000000UL >> 21); // No ID mask is set.
CANIDT2 = (uint8_t) (0x00000000UL >> 13);
CANIDT3 = (uint8_t) (0x00000000UL >> 5);
CANIDT4 = (uint8_t) (0x00000000UL << 3) | (0 << RTRTAG);
// An alternate 32 bit CANIDT register WinAVR example:
// CANIDT = (0x00000000UL << 3) | (0UL << RTRTAG);
// Mask to Rx all CAN IDs, any frame type and any 11/29 bit format.
CANIDM1 = (uint8_t) (0x00000000UL >> 21);
CANIDM2 = (uint8_t) (0x00000000UL >> 13);
CANIDM3 = (uint8_t) (0x00000000UL >> 5);
CANIDM4 = (uint8_t) (0x00000000UL << 3) | (0 << RTRMSK) | (0 << IDEMSK);
// An alternate 32 bit CANIDM register WinAVR example:
// CANIDM = (0x00000000UL << 3) | (0UL << RTRMSK) | (0UL << IDEMSK);
// Start the MOb 0 CAN Rx command.
CANCDMOB = MOB_RX_CMD | MOB_IDE_29F | MOB1_RX_DLC_DEFAULT;
}
//*******************************************************
// This processes each CAN CANSTMOB (ENRX and ENERR) and CANGIT (ENERG) interrupt providing
// Can_status for use by other functions to detect Mob 0 CAN activity. This is dedicated to
// only MOb 0. After CANSTMOB.RXOK is set MOb 0 is disabled and all MOb register Rx data is
// ready for use in other functions, up until later when Rx MOb 0 is re-enabled by a CANCDMOB
// command Rx write. No MOb 0 Rx data is extracted in this ISR. Combining CANSTMOB and CANGIT
// errors only makes sense because there is only one single MOb enabled in this test code.
//
ISR (CANIT_vect) {
uint8_t save_page; // Pre-interrupt CANPAGE value storage.
uint8_t gen_errors; // CAMGIT general error flag values.
save_page = CANPAGE; // Save the pre-interrupt CANPAGE value.
CANPAGE = (0 << MOBNB0); // Select MOb 0, AINC = 0, INDEX2:0 = 0.
// Only process CANSTMOB if it has something in it. Otherwise the CANSTMOB clear might
// conflict with a new CANSTMOB interrupt flag being set (this prevents a race condition).
if (CANSTMOB) {
// Get possible RXOK flag and concatenate (ENERR) with all previous MOb error flags.
Can_status |= CANSTMOB;
// Clear the CANSTMOB interrupt flags.
CANSTMOB = 0;
}
// Get a copy of all the gneral error flags that are set at this time.
gen_errors = (CANGIT & ((1 << SERG) | (1 << CERG) | (1 << FERG) | (1 << AERG)));
// Clear only the set error ENERG interrupt flags. This works differently from the
// CANSTMOB clear (see the data sheet). This method also avoids loosing any new just
// set now general error flag types when CANGIT is cleared.
CANGIT = gen_errors; // Clear only the already set error flags.
// Concatenate all the MOb error flags (ENERR) with the general error flags (ENERG).
Can_status |= gen_errors;
CANPAGE = save_page; // Restore the pre-interrupt CANPAGE value.
}
//*******************************************************
// The CAN MOb information is extracted here in main() by polling Can_status. Then after
// CANSTMOB.RXOK is detected the MOb 0 register storage has all the Rx updated information.
//
// FYI: Since this code does not have any Tx MObs, the BERR flag should never be set at any time.
//
int main(void) {
uint8_t dlc; // CANMSG byte total count.
uint8_t error_debug_flags = 0;
uint8_t error_debug_flags_last = 0;
uint8_t gen_error_flags_cleanup = 0;
can_init();
mob_init();
sei(); // enable interrupts globally
while (1) {
CANPAGE = (0 << MOBNB0); // Select MOb 0, AINC = 0, INDEX2:0 = 0.
error_debug_flags = Can_status; // Poll Can_status and save the result.
// The error_debug_flags_last ensures this debug only happens one time for each new type
// of error flag. Multiple occurrences of the same error flag are ignored. This is also
// triggered for RXOK even though this is not an error flag.
if (error_debug_flags != error_debug_flags_last) {
// Debug output of the error_debug_flags value.
// Debug output of CANREC and CANTEC values.
error_debug_flags_last = error_debug_flags;
}
// Check to see if the ISR CANIT finished the MOb 0 Rx.
if (error_debug_flags & (1 << RXOK)) { // Ignore all MOb 0 Rx results until a RXOK is set.
// After this any new CANGIT error flags will now be set in Can_status. No CANSTMOB
// flags will be set until after the MOb 0 Rx is restarted.
// Pickup any last new types of general error flags since the debug output above.
// Temporarily stop any new CANGIT error interrupts while cleaning up (the RXOK
// MOb 0 automatic disable has already stopped any CANSTMOB interrupts).
ATOMIC_BLOCK(ATOMIC_FORCEON)
{
gen_error_flags_cleanup = Can_status ^ error_debug_flags;
Can_status = 0; // Clear the last result to start over with a new Rx.
} // Restore CANGIT error interrupts (these are saved and reported in Can_status).
error_debug_flags = 0; // Reset the error_debug_flags for the next MOb 0 Rx cycle.
error_debug_flags_last = 0;
// Always limit RXOK updated CANCDMOB.DLC result to MOB_MAX_DLC.
dlc = MOB_DLC_LIMIT(CANCDMOB & MOB_DLC_FIELD);
// Debug output for gen_error_flags_cleanup.
// Debug output for MOb 0 information after the RXOK update. Add your own output code
// here or perhaps a JTAGICE/DebugWire breakpoint.
// CANCDMOB.IDE bit is the Rx updated 11/29 bit format.
// If CANCDMOB.IDE bit is 0 - 11 bit foramt.
// (CANIDT >> 21) bits are the Rx updated 11 bit ID value.
// If CANCDMOB.IDE bit is 1 - 29 bit format.
// (CANIDT >> 3) bits are the Rx updated 29 bit ID value.
// CANIDT4.RTRTAG bit is the Rx updated Data/Remote frame type.
// If CANIDT4.RTRTAG bit is 0
// read the dlc number of CANMSG bytes to get the CAN data for output.
// Restart the MOb 0 Rx (the RXOK disabled MOb 0, so we know it is ready again).
CANCDMOB = MOB_RX_CMD | MOB_IDE_11F | MOB1_RX_DLC_DEFAULT;
}
} // End of while(1) loop - no more executable code past this point.
}
FAQ
Search
Register
Log in to check your private messages
Log in
Maximize
RSS
? I know, its a silly question, but I had to ask anyway 
. Are you certain you have the correct DB-9 pin out for your CAN cable connections? The Olimex 120 ohm termination is factory enabled on mine, make sure this is the termination you are using for this board and not paralleling it with another built-in CAN cable connector terminator (some CAN cables have CAN bus resistor termination built into the cable assembly that do not use on-board termination resistors).
.