int main(void)
{
can_message_ msg;
GPIO_init();
CAN_init(125000, 0, 0, 8, &CAN_Message_Received);
USB_Init();
USB_Connect(TRUE);
A3984_init();
A3984_set_state(A3984_STATE_WAKEUP);
A3984_set_state(A3984_STATE_ACTIVE);
A3984_set_stepping(A3984_STEP_FULL);
A3984_set_direction(A3984_DIR_CW);
A3984_set_idle_current(100);
GPIO_clock_out(TRUE);
CAN_Message_(&msg, 0x0123, 0, 5, 'R', 'E', 'A', 'D', 'Y');
CAN_send(1, msg);
while (1)
{
#if A3984_CURRENT_ISR == 1
A3984_set_current_handler();
#endif
}
return 0 ;
}
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 geo_controller_init( void )
{
can_std_id_t dummy;
bool status = false;
can_id_sync_ack = CAN_gen_sid(GEO_CNTL_CANBUS, MASTER_SYNC_ACK_ID);
can_id_rst = CAN_gen_sid(GEO_CNTL_CANBUS, RESET_ID);
dummy = CAN_gen_sid(GEO_CNTL_CANBUS, 0xFFFF ); // Dummy entry for pairing
can_id_loc_update = CAN_gen_sid(GEO_CNTL_CANBUS, GEO_LOC_UPDATE_ID);
// Initialize the can bus
status = CAN_init(GEO_CNTL_CANBUS, GEO_CNTL_BAUD, GEO_CNTL_CANRXQ, GEO_CNTL_CANTXQ , bus_off_cb, data_ovr_cb);
if( !status )
{
LOG_ERROR("ERROR!!! Cannot initialize GEO controller CAN Bus!!");
return status;
}
// Setup full can filters
status = CAN_fullcan_add_entry(GEO_CNTL_CANBUS, can_id_rst, can_id_sync_ack);
status = CAN_fullcan_add_entry(GEO_CNTL_CANBUS, can_id_loc_update, dummy);
if( !status )
{
LOG_ERROR("ERROR!!! Cannot add FullCAN entries to GEO controller CAN Bus!!");
return status;
}
// Enable the bus
CAN_reset_bus(GEO_CNTL_CANBUS);
// Sync with the master controller by sending power_up_sync
// status = power_up_sync_geo_controller();
return status;
}
void MAIN_init(void)
{
USART_Init(MYUBRR);
fdevopen(USART_Transmit, USART_Receive);
//EXTMEM_init();
//OLED_init();
SPI_Init();
CAN_init();
sei();
}
/**
* @brief Put the controller in normal mode and make it receive incoming
* messages
*/
void CAN_test_normal_receive()
{
CAN_init(MCP_MODE_NORMAL);
CanMessage_t resp;
while (1)
{
_delay_ms(200);
resp = CAN_receive();
CAN_print_message(&resp);
}
}
int main()
{
// Peripheral initialisation
I2C_init();
LCD_init();
LCD_write("Loading...");
DEBUG_init();
// Function initialisation
WAVE_init();
synth_init();
CAN_init();
menu_display();
while (1)
{
menu_update();
}
// Keypad for synth debugging
/*int down = 0;
int key = -1;
while(1)
{
key = KEYPAD_get_key();
if ((key != -1) && !down)
{
int note = 69+key;
synth_note_on(note_to_freq(note),1.0);
LCD_write_int("%d",note_to_freq(note));
down = 1;
}
if ((key == -1) && down)
{
synth_note_off(1.0);
LCD_clear();
down = 0;
}
}*/
// Loop to allow interupts
while(1);
return(1);
}
bool can_init(void) {
bool status = false;
LE.init();
CAN_init(SENSOR_CNTL_CANBUS,SENSOR_CNTL_CANBAUD,SENSOR_CNTL_CANRXQ,SENSOR_CNTL_CANTXQ,can_bus_off_callback,0);
LOG_INFO("SENSOR_CNTL_CANBUS is initialized\n");
const can_std_id_t slist[] = { CAN_gen_sid(SENSOR_CNTL_CANBUS, RESET_ID),
CAN_gen_sid(SENSOR_CNTL_CANBUS, SENSOR_SYNC_ID) };
CAN_setup_filter(slist, 2, NULL, 0, NULL, 0, NULL, 0);
CAN_reset_bus(SENSOR_CNTL_CANBUS);
// Sync with the master controller by sending power_up_sync
status = true;//powerup_sync_sensor_controller();
return status;
}
int main (void) {
// Set PE1 to output
// Use pin 10 to light up an LED
DDRC |= _BV(PC0);
// ADC conf
ADCSRA |= _BV(ADEN) | _BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0);
// Set ADC reference to internal GND
ADCSRB |= _BV(AREFEN);
// Select ADC channel
ADMUX|= _BV(REFS0) | 6;
// Init ADC storage var
uint16_t reading = 0;
// Initialize CAN
CAN_init(CAN_ENABLED);
// Set the array msg to contain 3 bytes
uint8_t msg[2] = {0,0};
while(1) {
// Toggle PE1 (pin 10)
// Toggles power to pin 10 to create a "blink"
// if (reading > 500)
// {
// PORTC |= _BV(PC0);
// }
// else
// {
// PORTC &= ~_BV(PC0);
// }
// // Start ADC read
// ADCSRA |= _BV(ADSC);
// // Block until ADC completes
// while(bit_is_set(ADCSRA, ADSC));
// // Store value
// reading = ADC;
// //SEND CAN MSG
// msg = {reading >> 8, reading & ~(0xff << 8)};
// // Transmit message
// CAN_transmit( 0, 0x15, 2, msg);
PORTC ^= _BV(PC0);
_delay_ms(500);
}
}
void
OBD_init( void )
{
g_OBD_state_client = OBD_STATE_IDLE;
g_OBD_state_server = OBD_STATE_IDLE;
g_OBD_dataRequestErrors = 0;
CAN_init( g_OBD_rxDataBuffer,
sizeof(g_OBD_rxDataBuffer),
OBD_rxCallback,
OBD_errorCallback );
/* Enable loopback mode for testing */
CAN_setOperatingMode( CAN_OPMODE_LOOPBACK );
}
/**
* @brief Put the controller in normal mode and make it send the same message
* over and over again
*/
void CAN_test_normal_send()
{
CAN_init(MCP_MODE_NORMAL);
CanMessage_t message;
message.id = 15;
message.length = 4;
message.data[0] = 'T';
message.data[1] = 'E';
message.data[2] = 'S';
message.data[3] = 'T';
while (1)
{
CAN_send(&message);
printf("Message sent!\n");
//_delay_ms(200);
}
}
/**
* @brief Put the CAN controller in loopback mode and test local features
*/
void CAN_test_loopback()
{
CAN_init(MCP_MODE_LOOPBACK);
CanMessage_t message;
CanMessage_t resp;
message.id = 15;
message.length = 4;
message.data[0] = 'T';
message.data[1] = 'E';
message.data[2] = 'S';
message.data[3] = 'T';
while (1)
{
CAN_send(&message);
_delay_ms(200);
resp = CAN_receive();
CAN_print_message(&resp);
}
}
void mainInit()
{
USART_Init(MYUBRR);
fdevopen(USART_Transmit, USART_Receive);
SPI_Init();
CAN_init();
SERVO_init();
TWI_Master_Initialise();
SOLENOID_init();
MOTOR_init();
IR_init();
sei();
}
bool CAN_test(void)
{
#define CAN_TEST_RX 0
CAN_ASSERT(!CAN_init(can_inv, 100, 0, 0, NULL, NULL));
CAN_ASSERT(CAN_init(can1, 100, 0, 0, CAN_test_bufoff_cb, CAN_test_bufovr_cb));
CAN_ASSERT(LPC_CAN1->MOD == can_mod_reset);
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_normal);
/* Send 11-bit CANID message */
uint32_t id = 0x100;
can_msg_t msg;
msg.frame = 0;
msg.msg_id = id;
msg.frame_fields.is_29bit = 0;
msg.frame_fields.data_len = 7;
msg.data.qword = 0x1122334455667788;
CAN_ASSERT(!CAN_tx(can_inv, &msg, 0));
CAN_ASSERT(!CAN_rx(can1, &msg, 0));
/* Send msg and test receive */
CAN_ASSERT(CAN_tx(can1, &msg, 0));
#if CAN_TEST_RX
memset(&msg, 0, sizeof(msg));
CAN_ASSERT(CAN_rx(can1, &msg, 1000));
CAN_ASSERT(msg.msg_id = id);
CAN_ASSERT(!msg.frame_fields.is_29bit);
#endif
/* Test filters */
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(4 == LPC_CANAF->SFF_sa);
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_ASSERT(0 != fc1);
CAN_ASSERT(0 != fc2);
#if CAN_TEST_RX
/* 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;
can_fullcan_msg_t fc_temp;
CAN_ASSERT(!CAN_fullcan_read_msg_copy(fc1, &fc_temp));
CAN_ASSERT(CAN_tx(can1, &msg, 0));
CAN_ASSERT(CAN_fullcan_read_msg_copy(fc1, &fc_temp));
CAN_ASSERT(fc1->msg_id == id);
#endif
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, 0x150), CAN_gen_sid(can1, 0x200)}, // Group 1
{CAN_gen_sid(can2, 0x300), CAN_gen_sid(can2, 0x400)} // Group 2
};
const can_ext_id_t *elist = NULL; // Not used, so set it to NULL
const can_ext_grp_id_t eglist[] = { {CAN_gen_eid(can1, 0x3500), CAN_gen_eid(can1, 0x4500)} }; // Group 1
/* Test filter setup */
CAN_setup_filter(slist, 4, sglist, 2, elist, 0, eglist, 1);
CAN_ASSERT(2 == CAN_fullcan_get_num_entries());
CAN_ASSERT(LPC_CANAF->SFF_sa == 4);
CAN_ASSERT(LPC_CANAF->SFF_GRP_sa == 12);
CAN_ASSERT(LPC_CANAF->EFF_sa == 20);
CAN_ASSERT(LPC_CANAF->EFF_GRP_sa == 20);
CAN_ASSERT(LPC_CANAF->ENDofTable == 28);
/* Send a message defined in filter */
/* Send a message not defined in filter */
return true;
}
int main(void)
{
/* Configure Oscillator to operate the device at 30Mhz
Fosc= Fin*M/(N1*N2), Fcy=Fosc/2
Fosc= 7.37*(32)/(2*2)=58.96Mhz for Fosc, Fcy = 29.48Mhz */
/* Configure PLL prescaler, PLL postscaler, PLL divisor */
//PLLFBDbits.PLLDIV=38; /* M = PLLFBD + 2 */ // izlazna frekvencija = 30Mhz
//Fin=8MHz, Fcy=30MHz
// Configure PLL prescaler, PLL postscaler, PLL divisor
PLLFBD = 28; // M=40 ---> PLLFBD + 2 = M
CLKDIVbits.PLLPOST = 0; // N2=2 ---> 2x(PLLPOST + 2) = N2
CLKDIVbits.PLLPRE = 0; // N1=2 ---> PLLPRE + 2 = N1
//new oscillator selection
__builtin_write_OSCCONH(0b011); //0b011 ---> XT with PLL
//enable oscillator source switch
__builtin_write_OSCCONL (OSCCONL | (1<<0)); //OSWEN
//wait for PLL lock -> wait to new settings become available
while (OSCCONbits.COSC != 0b011);
//wait for PLL lock
while (OSCCONbits.LOCK != 0b1);
AD1PCFGL = 0xFFFF;// all PORT Digital
RPINR18bits.U1RXR = 0; //UART1 RX na RP0- pin 4
RPOR0bits.RP1R = 3; //UART1 TX na RP1- pin 5
RPINR14bits.QEA1R = 2; //QEI1A na RP2
RPINR14bits.QEB1R = 3; //QEI1B na RP3
RPINR16bits.QEA2R = 4; //QEI2A na RP4
RPINR16bits.QEB2R = 7; //QEI2B na RP7
CAN_init(DRIVER_IDENTIFICATOR); // inicijalizacija CAN BUS- a-> argument je adresa drajvera
int tmp;
char komanda, v, smer;
int Xc, Yc, ugao;
NewLine();
PortInit();
//UARTinit();
TimerInit();
QEIinit();
PWMinit();
// CloseMCPWM();
resetDriver();
setSpeed(0x80);
setSpeedAccel(K2); //K2 je za 1m/s /bilo je 2
int tmpX, tmpY, tmpO;
unsigned char rxBuffer[8];
while(1)
{
__delay_ms(1000);
setSpeed(30);
// kretanje_pravo(-1000, 0);
if(getStatus() == STATUS_MOVING)
CAN_getLastMessage(rxBuffer);
else
CAN_read(rxBuffer);
komanda = rxBuffer[0];
switch(komanda)
{
// zadavanje pozicije
case 'I':
tmpX = rxBuffer[1] << 8;
tmpX |= rxBuffer[2];
tmpY = rxBuffer[3] << 8;
tmpY |= rxBuffer[4];
tmpO = rxBuffer[5] << 8;
tmpO |= rxBuffer[6];
setPosition(tmpX, tmpY, tmpO);
break;
// citanje pozicije i statusa
case 'P':
sendStatusAndPosition();
break;
//zadavanje max. brzine (default K2/2)
case 'V':
tmp = rxBuffer[1];
setSpeed(tmp);
break;
//kretanje pravo [mm]
case 'D':
tmp = rxBuffer[1] << 8;
tmp |= rxBuffer[2];
v = rxBuffer[3];
PWMinit();
kretanje_pravo(tmp, v);
break;
//relativni ugao [stepen]
case 'T':
tmp = rxBuffer[1] << 8;
tmp |= rxBuffer[2];
PWMinit();
okret(tmp);
break;
//apsolutni ugao [stepen]
case 'A':
tmp = rxBuffer[1] << 8;
tmp |= rxBuffer[2];
PWMinit();
apsolutni_ugao(tmp);
break;
//idi u tacku (Xc, Yc) [mm]
case 'G':
tmpX = rxBuffer[1] << 8;
tmpX |= rxBuffer[2];
tmpY = rxBuffer[3] << 8;
tmpY |= rxBuffer[4];
v = rxBuffer[5];
smer = rxBuffer[6];
PWMinit();
gotoXY(tmpX, tmpY, v, smer);
break;
//kurva
case 'Q':
tmpX = rxBuffer[1] << 8;
tmpX |= rxBuffer[2];
tmpY = rxBuffer[3] << 8;
tmpY |= rxBuffer[4];
tmpO = rxBuffer[5] << 8;
tmpO |= rxBuffer[6];
smer = rxBuffer[7];
PWMinit();
kurva(tmpX, tmpY, tmpO, smer);
break;
//ukopaj se u mestu
case 'S':
stop();
break;
//stani i ugasi PWM
case 's':
stop();
CloseMCPWM();
break;
case 'R':
resetDriver();
break;
default:
forceStatus(STATUS_ERROR);
break;
}
}
return 0;
}
bool bluetooth_controller_sync()
{
bool can_init_stat = false;
bool sync_tx_status = false;
bool sync_ack_status = true;
bool status = false;
SoftTimer can_rx_timer(BT_SYNC_TIME);
//Initialize can bus for sync frame transmission
can_init_stat = CAN_init(can_controller, can_baud_kbps, can_rx_queue_size, can_tx_queue_size, bus_off_cb, data_ovr_cb);
PRINT("can init started\n");
master_sync *ref_obj;
if(!can_init_stat)
{
LOG_ERROR("Bluetooth controller CAN bus could not be initialiazed");
return can_init_stat;
}
else
PRINT("\ncan init successful");
const can_std_id_t slist[] = {CAN_gen_sid(can_controller, MASTER_SYNC_ACK_ID), CAN_gen_sid(can_controller, CHECKPOINT_REQ_ID), CAN_gen_sid(can_controller, GEO_LOC_DATA_ID), CAN_gen_sid(can_controller, 0xFFFF)};
CAN_setup_filter(slist, 4, NULL, 0, NULL, 0, NULL, 0);
//CAN_bypass_filter_accept_all_msgs();
CAN_reset_bus(can_controller);
tx_mssg.msg_id = BLUETOOTH_SYNC_ID;
tx_mssg.frame_fields.data_len = 0;
tx_mssg.frame_fields.is_29bit = 0;
tx_mssg.data.qword = 0;
do
{
PRINT("\n can tx status = %d",sync_tx_status);
sync_tx_status = CAN_tx(can_controller, &tx_mssg,BT_CNTRL_TIMEOUT_CAN);
PRINT("\ncan tx started");
PRINT("\n can tx status = %d",sync_tx_status);
if(sync_tx_status)
{
PRINT("\ncan tx successful no errors");
}
else
{
LOG_ERROR("Bluetooth can message cannot be sent");
PRINT("\ncan tx unsuccessfull");
}
can_rx_timer.restart();
while(!can_rx_timer.expired());
status = CAN_rx(can_controller,&master_rx_mssg, BT_CNTRL_TIMEOUT_CAN);
PRINT("\ncan rx started");
if(status)
{
ref_obj = (master_sync*)&(master_rx_mssg.data.bytes[0]);
PRINT("\ncan rx successful");
if((master_rx_mssg.msg_id == MASTER_SYNC_ACK_ID) && (ref_obj->ack_bluetooth == 1))
sync_ack_status = true;
}
}while(sync_ack_status == false);
PRINT("\nack received successful\n");
return sync_ack_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;
}
int main(void){
//!< Temperature Reference resistors. Value defined in config.h
RefRes[0]=RES_REF1;
RefRes[1]=RES_REF2;
RefRes[2]=RES_REF3;
RefRes[3]=RES_REF4;
//!< Sets the connected Cells. Value defined in config.h
ActiveCells[0] = CELLSIC1;
ActiveCells[1] = CELLSIC2;
ActiveCells[2] = CELLSIC3;
ActiveCells[3] = CELLSIC4;
CCInit(); // Coulombcounter Init
SPI_MasterInit(); // SPI Init
TimerInit(DELAY_TIM_FREQUENCY); // Timer prescaler Init
CLK_init(CHIP_CLK); // Start Frequency output for ATA6870(kHz)
CAN_init(); //Setup CAN bus
while(OpenCellcheck()){ //Checks for open Clamps
_delay_ms(50);
}
// sei(); // enable interrupt
while(1){
if(ATA6870_state){
PD_N_ON();
}
else{
PD_N_OFF();
}
//----------------------------- Vacq 1---------------------------------------//
ATA6870_SPI_COM(0x01,0x0B,0x02);//wakeup irq surpressed
_delay_ms(20);
ActiveTemp=0x00; //Set measured Temperature Channel
ATA6870_SPI_COM(0x01,0x05,0x03);//Vacq Temp Channel 1
_delay_ms(20);
ATA6870_SPI_COM(0x01,0x0C,0x00);//Read Status Reg
_delay_ms(20);
operation=0x03;
ATA6870_SPI_COM(0x01,0xFE,0x00);//Burstread
_delay_ms(20);
ReadNTC();
//------------------------------ Offset acq 1---------------------------------//
ATA6870_SPI_COM(0x01,0x05,0x01);//Offset acq
_delay_ms(20);
ATA6870_SPI_COM(0x01,0x0C,0x00);//Read Status Reg
_delay_ms(20);
operation=0x01;
ATA6870_SPI_COM(0x01,0xFE,0x00);//Burstread
_delay_ms(20);
//--------------------------------- Check 1------------------------------------//
CalculateV(0x01);
//----------------------------- NTC2 Chip1---------------------------------------//
ActiveTemp=0x01; //Set measured Temperature Channel
ATA6870_SPI_COM(0x01,0x05,0x0B);//Vacq Temp Channel 2
_delay_ms(20);
ATA6870_SPI_COM(0x01,0x0C,0x00);//Read Status Reg
_delay_ms(20);
operation=0x03;
ATA6870_SPI_COM(0x01,0xFE,0x00);//Burstread
_delay_ms(20);
ReadNTC();
//--------------------------------- Vacq 2--------------------------------------//
ATA6870_SPI_COM(0x02,0x0B,0x02);//wakeup irq surpressed
_delay_ms(20);
ATA6870_SPI_COM(0x02,0x05,0x03);//Vacq Temp Channel 1
_delay_ms(20);
ATA6870_SPI_COM(0x02,0x0C,0x00);//Read Status Reg
_delay_ms(20);
operation=0x03;
ATA6870_SPI_COM(0x02,0xFE,0x00);//Burstread
_delay_ms(20);
//------------------------------ Offset acq 2----------------------------------//
ATA6870_SPI_COM(0x02,0x05,0x01);//Offset acq
_delay_ms(20);
ATA6870_SPI_COM(0x02,0x0C,0x00);//Read Status Reg
_delay_ms(20);
operation=0x01;
ATA6870_SPI_COM(0x02,0xFE,0x00);//Burstread
_delay_ms(20);
//------------------------------------ Check 2----------------------------------//
CalculateV(0x02);
if(Undervoltage(25000,0x01)||Overvoltage(42000,0x01)||Undervoltage(25000,0x02)||Overvoltage(42000,0x02)||Temp[0]<=(T_LOWERTRESHOLD)||Temp[0]>=T_UPPERTHRESHOLD||Temp[1]<=(T_LOWERTRESHOLD)||Temp[1]>=T_UPPERTHRESHOLD){
Configure_Fet(0x00);
}
else{
Configure_Fet(0x03);
}
}
}
