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); } } }