bool can_init(void) {
bool status = false;
no_motor_msg.data.bytes[0] = (uint8_t) 0 ; // Stop speed
no_motor_msg.data.bytes[1] = (uint8_t) 2 ; // Straight direction
LE.init();
status = CAN_init(MOTORIO_CNTL_CANBUS,MOTORIO_CNTL_CANBAUD,MOTORIO_CNTL_CANRXQ,MOTORIO_CNTL_CANTXQ,can_bus_off_callback,data_over_callback);
if( !status )
{
LOG_ERROR("ERROR!!! Cannot initialize MOTORIO controller CAN Bus!!");
return status;
}
LOG_INFO("MOTORIO CAN bus is initialized\n");
// Setup necessary message filter
//const can_std_id_t slist[] = { CAN_gen_sid(MOTORIO_CNTL_CANBUS, RESET_ID), CAN_gen_sid(MOTORIO_CNTL_CANBUS, MASTER_SYNC_ACK_ID),
// CAN_gen_sid(MOTORIO_CNTL_CANBUS, RUN_MODE_ID), CAN_gen_sid(MOTORIO_CNTL_CANBUS, MOTOR_DIRECTIONS_ID)
// };
CAN_bypass_filter_accept_all_msgs();
//CAN_setup_filter(slist, 4, NULL, 0, NULL, 0, NULL, 0);
CAN_reset_bus(MOTORIO_CNTL_CANBUS);
// Sync with the master controller by sending power_up_sync
status = true;//powerup_sync_motor_io_controller();
return status;
}
bool CAN_test(void)
{
uint32_t i = 0;
#define can_test_msg(msg, id, rxtrue) do { \
u0_dbg_printf("Send ID: 0x%08X\n", id); \
msg.msg_id = id; \
CAN_ASSERT(CAN_tx(can1, &msg, 0)); \
msg.msg_id = 0; \
CAN_ASSERT(rxtrue == CAN_rx(can1, &msg, 10)); \
if (rxtrue) CAN_ASSERT(id == msg.msg_id); \
} while(0)
u0_dbg_printf(" Test init()\n");
CAN_ASSERT(!CAN_init(can_max, 100, 0, 0, NULL, NULL));
CAN_ASSERT(CAN_init(can1, 100, 5, 5, CAN_test_bufoff_cb, CAN_test_bufovr_cb));
CAN_ASSERT(LPC_CAN1->MOD == can_mod_reset);
CAN_bypass_filter_accept_all_msgs();
CAN_ASSERT(g_can_rx_qs[0] != NULL);
CAN_ASSERT(g_can_tx_qs[0] != NULL);
CAN_ASSERT(LPC_CANAF->SFF_sa == 0);
CAN_ASSERT(LPC_CANAF->SFF_GRP_sa == 0);
CAN_ASSERT(LPC_CANAF->EFF_sa == 0);
CAN_ASSERT(LPC_CANAF->EFF_GRP_sa == 0);
CAN_ASSERT(LPC_CANAF->ENDofTable == 0);
CAN_reset_bus(can1);
CAN_ASSERT(LPC_CAN1->MOD == can_mod_selftest);
/* Create a message, and test tx with bad input */
uint32_t id = 0x100;
can_msg_t msg;
memset(&msg, 0, sizeof(msg));
msg.frame = 0;
msg.msg_id = id;
msg.frame_fields.is_29bit = 0;
msg.frame_fields.data_len = 8;
msg.data.qword = 0x1122334455667788;
CAN_ASSERT(!CAN_tx(can_max, &msg, 0)); // Invalid CAN
CAN_ASSERT(!CAN_rx(can1, NULL, 0)); // Invalid message pointer
/* Send msg and test receive */
u0_dbg_printf(" Test Tx/Rx\n");
can_test_msg(msg, 0x100, true);
can_test_msg(msg, 0x200, true);
can_test_msg(msg, 0x300, true);
can_test_msg(msg, 0x400, true);
can_test_msg(msg, 0x500, true);
const can_std_id_t slist[] = { CAN_gen_sid(can1, 0x100), CAN_gen_sid(can1, 0x110), // 2 entries
CAN_gen_sid(can1, 0x120), CAN_gen_sid(can1, 0x130) // 2 entries
};
const can_std_grp_id_t sglist[] = { {CAN_gen_sid(can1, 0x200), CAN_gen_sid(can1, 0x210)}, // Group 1
{CAN_gen_sid(can1, 0x220), CAN_gen_sid(can1, 0x230)} // Group 2
};
const can_ext_id_t elist[] = { CAN_gen_eid(can1, 0x7500), CAN_gen_eid(can1, 0x8500)};
const can_ext_grp_id_t eglist[] = { {CAN_gen_eid(can1, 0xA000), CAN_gen_eid(can1, 0xB000)} }; // Group 1
/* Test filter setup */
u0_dbg_printf(" Test filter setup\n");
CAN_setup_filter(slist, 4, sglist, 2, elist, 2, eglist, 1);
/* We use offset of zero if 2 FullCAN messages are added, otherwise 4 if none were added above */
const uint8_t offset = 4;
CAN_ASSERT(LPC_CANAF->SFF_sa == 4 - offset);
CAN_ASSERT(LPC_CANAF->SFF_GRP_sa == 12 - offset);
CAN_ASSERT(LPC_CANAF->EFF_sa == 20 - offset);
CAN_ASSERT(LPC_CANAF->EFF_GRP_sa == 28 - offset);
CAN_ASSERT(LPC_CANAF->ENDofTable == 36 - offset);
for ( i = 0; i < 10; i++) {
u0_dbg_printf("%2i: 0x%08X\n", i, (uint32_t) LPC_CANAF_RAM->mask[i]);
}
/* Send a message defined in filter */
u0_dbg_printf(" Test filter messages\n");
msg.frame = 0;
msg.frame_fields.is_29bit = 0;
msg.frame_fields.data_len = 8;
msg.data.qword = 0x1122334455667788;
/* Test reception of messages defined in the filter */
u0_dbg_printf(" Test message reception according to filter\n");
msg.frame_fields.is_29bit = 0;
can_test_msg(msg, 0x100, true); // standard id
can_test_msg(msg, 0x110, true); // standard id
can_test_msg(msg, 0x120, true); // standard id
can_test_msg(msg, 0x130, true); // standard id
can_test_msg(msg, 0x200, true); // Start of standard ID group
can_test_msg(msg, 0x210, true); // Last of standard ID group
can_test_msg(msg, 0x220, true); // Start of standard ID group
can_test_msg(msg, 0x230, true); // Last of standard ID group
msg.frame_fields.is_29bit = 1;
can_test_msg(msg, 0x7500, true); // extended id
can_test_msg(msg, 0x8500, true); // extended id
can_test_msg(msg, 0xA000, true); // extended id group start
can_test_msg(msg, 0xB000, true); // extended id group end
u0_dbg_printf(" Test messages that should not be received\n");
/* Send a message not defined in filter */
msg.frame_fields.is_29bit = 0;
can_test_msg(msg, 0x0FF, false);
can_test_msg(msg, 0x111, false);
can_test_msg(msg, 0x131, false);
can_test_msg(msg, 0x1FF, false);
can_test_msg(msg, 0x211, false);
can_test_msg(msg, 0x21f, false);
can_test_msg(msg, 0x231, false);
msg.frame_fields.is_29bit = 1;
can_test_msg(msg, 0x7501, false);
can_test_msg(msg, 0x8501, false);
can_test_msg(msg, 0xA000-1, false);
can_test_msg(msg, 0xB000+1, false);
/* Test FullCAN */
u0_dbg_printf(" Test FullCAN\n");
CAN_init(can1, 100, 5, 5, CAN_test_bufoff_cb, CAN_test_bufovr_cb);
CAN_reset_bus(can1);
id = 0x100;
CAN_ASSERT(0 == CAN_fullcan_get_num_entries());
CAN_ASSERT(CAN_fullcan_add_entry(can1, CAN_gen_sid(can1, id), CAN_gen_sid(can1, id+1)));
CAN_ASSERT(2 == CAN_fullcan_get_num_entries());
CAN_ASSERT(LPC_CANAF->SFF_sa == 4);
CAN_ASSERT(LPC_CANAF->SFF_GRP_sa == 4);
CAN_ASSERT(LPC_CANAF->EFF_sa == 4);
CAN_ASSERT(LPC_CANAF->EFF_GRP_sa == 4);
CAN_ASSERT(LPC_CANAF->ENDofTable == 4);
CAN_ASSERT(CAN_fullcan_add_entry(can1, CAN_gen_sid(can1, id+2), CAN_gen_sid(can1, id+3)));
CAN_ASSERT(4 == CAN_fullcan_get_num_entries());
CAN_ASSERT(LPC_CANAF->SFF_sa == 8);
for ( i = 0; i < 3; i++) {
u0_dbg_printf("%2i: 0x%08X\n", i, (uint32_t) LPC_CANAF_RAM->mask[i]);
}
can_fullcan_msg_t *fc1 = CAN_fullcan_get_entry_ptr(CAN_gen_sid(can1, id));
can_fullcan_msg_t *fc2 = CAN_fullcan_get_entry_ptr(CAN_gen_sid(can1, id+1));
can_fullcan_msg_t *fc3 = CAN_fullcan_get_entry_ptr(CAN_gen_sid(can1, id+2));
can_fullcan_msg_t *fc4 = CAN_fullcan_get_entry_ptr(CAN_gen_sid(can1, id+3));
CAN_ASSERT((LPC_CANAF_RAM_BASE + LPC_CANAF->SFF_sa) == (uint32_t)fc1);
CAN_ASSERT((LPC_CANAF_RAM_BASE + LPC_CANAF->SFF_sa + 1*sizeof(can_fullcan_msg_t)) == (uint32_t)fc2);
CAN_ASSERT((LPC_CANAF_RAM_BASE + LPC_CANAF->SFF_sa + 2*sizeof(can_fullcan_msg_t)) == (uint32_t)fc3);
CAN_ASSERT((LPC_CANAF_RAM_BASE + LPC_CANAF->SFF_sa + 3*sizeof(can_fullcan_msg_t)) == (uint32_t)fc4);
can_fullcan_msg_t fc_temp;
CAN_ASSERT(!CAN_fullcan_read_msg_copy(fc1, &fc_temp));
CAN_ASSERT(!CAN_fullcan_read_msg_copy(fc2, &fc_temp));
CAN_ASSERT(!CAN_fullcan_read_msg_copy(fc3, &fc_temp));
CAN_ASSERT(!CAN_fullcan_read_msg_copy(fc4, &fc_temp));
/* Send message, see if fullcan captures it */
msg.frame = 0;
msg.msg_id = id;
msg.frame_fields.is_29bit = 0;
msg.frame_fields.data_len = 8;
#define can_test_fullcan_msg(fc, msg_copy, id) \
do { \
msg.msg_id = id; \
CAN_ASSERT(CAN_tx(can1, &msg, 0)); \
CAN_ASSERT(!CAN_rx(can1, &msg, 10)); \
CAN_ASSERT(CAN_fullcan_read_msg_copy(fc, &msg_copy)); \
CAN_ASSERT(fc->msg_id == id) \
} while(0)
can_test_fullcan_msg(fc1, fc_temp, id+0); CAN_ASSERT(!CAN_fullcan_read_msg_copy(fc2, &fc_temp));
can_test_fullcan_msg(fc2, fc_temp, id+1); CAN_ASSERT(!CAN_fullcan_read_msg_copy(fc3, &fc_temp));
can_test_fullcan_msg(fc3, fc_temp, id+2); CAN_ASSERT(!CAN_fullcan_read_msg_copy(fc4, &fc_temp));
can_test_fullcan_msg(fc4, fc_temp, id+3); CAN_ASSERT(!CAN_fullcan_read_msg_copy(fc1, &fc_temp));
u0_dbg_printf(" \n--> All tests successful! <--\n");
return true;
}
