/** * Test nvm_eeprom_erase_bytes_in_page() and * nvm_eeprom_erase_bytes_in_all_pages() * * Test procedure: * - Write two bytes into page TEST_ERASE_BYTES_PAGE_1 and * TEST_ERASE_BYTES_PAGE_2 * - Load value to page buffer in the address of the first byte * - Erase first byte of TEST_ERASE_BYTES_PAGE_1 * - Verify that first byte is deleted in TEST_ERASE_BYTES_PAGE_1 * - Load value to page buffer in the address of the first byte * - Erase first byte of all pages * - Verify that first byte is deleted in TEST_ERASE_BYTES_PAGE_2 * * \return STATUS_OK if test succeeded, otherwise ERR_BAD_DATA */ static status_code_t test_erase_bytes(void) { set_buffer(buffer, EEPROM_ERASED); buffer[0] = 0xaa; buffer[1] = 0xaf; /* Write two bytes into first page */ nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_1 * EEPROM_PAGE_SIZE + 0, buffer[0]); nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_1 * EEPROM_PAGE_SIZE + 1, buffer[1]); /* Write two bytes into second page */ nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_2 * EEPROM_PAGE_SIZE + 0, buffer[0]); nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_2 * EEPROM_PAGE_SIZE + 1, buffer[1]); /* Erase first byte of the first page */ nvm_eeprom_load_byte_to_buffer(0, 0xff); nvm_eeprom_erase_bytes_in_page(TEST_ERASE_BYTES_PAGE_1); buffer[0] = EEPROM_ERASED; if (is_eeprom_page_equal_to_buffer(TEST_ERASE_BYTES_PAGE_1, buffer)) { /* Erase first byte of all pages */ nvm_eeprom_load_byte_to_buffer(0, 0xff); nvm_eeprom_erase_bytes_in_all_pages(); if (is_eeprom_page_equal_to_buffer(TEST_ERASE_BYTES_PAGE_2, buffer)) { return STATUS_OK; } } return ERR_BAD_DATA; }
/** * \brief Test EEPROM read buffer * * This test erases test page \ref TEST_READ_BUFFER_PAGE then writes four bytes * to the test page and tries to read the entire page using * nvm_eeprom_read_buffer. * It then compares the read page with what's actually in the EEPROM page. * * \param test Current test case. */ static void run_eeprom_read_buffer_test(const struct test_case *test) { uint8_t buffer[EEPROM_PAGE_SIZE]; uint8_t buffer_read[EEPROM_PAGE_SIZE]; bool success; set_buffer(buffer, EEPROM_ERASED); buffer[0] = 0x11; buffer[1] = 0xaa; buffer[2] = 0xee; buffer[3] = 0x22; // Erase page nvm_eeprom_erase_bytes_in_page(TEST_READ_BUFFER_PAGE); // Write 4 bytes into page: nvm_eeprom_write_byte(TEST_READ_BUFFER_PAGE * EEPROM_PAGE_SIZE + 0, buffer[0]); nvm_eeprom_write_byte(TEST_READ_BUFFER_PAGE * EEPROM_PAGE_SIZE + 1, buffer[1]); nvm_eeprom_write_byte(TEST_READ_BUFFER_PAGE * EEPROM_PAGE_SIZE + 2, buffer[2]); nvm_eeprom_write_byte(TEST_READ_BUFFER_PAGE * EEPROM_PAGE_SIZE + 3, buffer[3]); nvm_eeprom_read_buffer(TEST_READ_BUFFER_PAGE * EEPROM_PAGE_SIZE, &buffer_read, EEPROM_PAGE_SIZE); // Check that what we have read is actually what's in EEPROM. success = is_eeprom_page_equal_to_buffer(TEST_READ_BUFFER_PAGE, buffer_read); test_assert_true(test, success, "Read buffer failed"); }
/** * \brief LCD interrupt callback function * * This function is called when an interrupt has occurred on LCD. */ void lcd_interrupt_callback(void) { uint32_t buf_temp; // Change text string on LCD when a button is pressed if (ui_pusb_button_0()) { ui_display_text(lcd_msg_gain_cal, sizeof(lcd_msg_gain_cal)); c42048a_clear_pixel(ICON_DEGREE_C); c42048a_clear_pixel(ICON_MILLI_VOLT); test_release_button_gain_cal = true; } //to limit EEPROM write operations, CAL stored when button released if((ui_pusb_button_0() == false) && (test_release_button_gain_cal == true)) { buf_temp = (((uint32_t)ext_voltage - ext_offset_cal_val) *8000/4095); buf_temp = buf_temp * ADC_GAIN_EXT; buf_temp = buf_temp / ext_gain_cal_val; //store gain value in Flash memory if(((buf_temp > EXT_GAIN_MIN_VAL) && (buf_temp < EXT_GAIN_MAX_VAL))){ ext_gain_cal_val = buf_temp; nvm_eeprom_write_byte(ext_gain_cal_addr + 1 , (uint8_t)(buf_temp>>8)); nvm_eeprom_write_byte(ext_gain_cal_addr, (uint8_t)(buf_temp)); }
status_code_t nvm_write_char(mem_type_t mem, uint32_t address, uint8_t data) { switch (mem) { case INT_FLASH: nvm_flash_erase_and_write_buffer((flash_addr_t)address, (const void *)&data, 1, true); break; case INT_USERPAGE: nvm_user_sig_write_buffer((flash_addr_t)address, (const void *)&data, 1, true); break; case INT_EEPROM: nvm_eeprom_write_byte((eeprom_addr_t)address, data); break; #if defined(USE_EXTMEM) && defined(CONF_BOARD_AT45DBX) case AT45DBX: if (!at45dbx_write_byte_open(address)) { return ERR_BAD_ADDRESS; } at45dbx_write_byte(data); at45dbx_write_close(); #endif default: return ERR_INVALID_ARG; } return STATUS_OK; }
/** * \brief This function will store the calculated calibration value in EEPROM * - Erase all eeprom locations * - Store the calculated calibration value in EEPROM */ void rtccalib_store_ppm_val(void) { /* Erase all eeprom locations */ nvm_eeprom_erase_all(); /* Store the calculated calibration value in EEPROM at configured * EEPROM address */ nvm_eeprom_write_byte(RTCCALIB_EEPROM_ADDR_TO_STORE, rtccalib_rtc_clk_calib_val); /* Store the status of RTC calibration in EEPROM at configured * EEPROM address * Success indicated as 0x01 and failure as 0x02 */ nvm_eeprom_write_byte(RTCCALIB_STAT_EEPROM_ADDR, rtccalib_rtc_clk_calib_status); }
/** * Test nvm_eeprom_erase_all(). * * Test procedure: * - Write one byte to the TEST_ERASE_PAGE page. * - Erase all memory locations * - Verify that the EEPROM is erased by a spot test on the * TEST_ERASE_PAGE page. * * \return STATUS_OK if test succeeded, otherwise ERR_BAD_DATA */ static status_code_t test_erase(void) { nvm_eeprom_write_byte(TEST_ERASE_PAGE * EEPROM_PAGE_SIZE, 42); nvm_eeprom_erase_all(); set_buffer(buffer, EEPROM_ERASED); if (is_eeprom_page_equal_to_buffer(TEST_ERASE_PAGE, buffer)) { return STATUS_OK; } return ERR_BAD_DATA; }
/** * \brief Test EEPROM erase * * This test writes a single byte to test page \ref TEST_ERASE_PAGE, then erases * _all_ pages and checks that the test page contains only \ref EEPROM_ERASED. * * \param test Current test case. */ static void run_eeprom_erase_test(const struct test_case *test) { uint8_t buffer[EEPROM_PAGE_SIZE]; bool success; nvm_eeprom_write_byte(TEST_ERASE_PAGE * EEPROM_PAGE_SIZE, 42); nvm_eeprom_erase_all(); set_buffer(buffer, EEPROM_ERASED); success = is_eeprom_page_equal_to_buffer(TEST_ERASE_PAGE, buffer); test_assert_true(test, success, "Page was not erased"); }
/** * \brief Copy a RAM buffer to a eeprom memory section * * \param dst Pointer to flash destination. * \param src Pointer to source data. * \param nbytes Number of bytes to transfer. */ static void mem_eeprom_write(isp_addr_t dst, const void *src, uint16_t nbytes) { #if (FLASH_SIZE==0x10000) // Optimize CODE space (150B), but decrease the speed // 24s to program 2KB instead of 1s while (nbytes--) { nvm_eeprom_write_byte(dst++, *(uint8_t*)src); src = (uint8_t*)src + 1; } #else nvm_eeprom_erase_and_write_buffer(dst, src, nbytes); #endif }
/** * \brief Test EEPROM write * * This test erases test page \ref TEST_WRITE_PAGE, then writes a single byte to * it and verifies that the write succeeded. * * \param test Current test case. */ static void run_eeprom_write_test(const struct test_case *test) { uint8_t buffer[EEPROM_PAGE_SIZE]; bool success; nvm_eeprom_erase_page(TEST_WRITE_PAGE); set_buffer(buffer, EEPROM_ERASED); buffer[0] = 0xaa; nvm_eeprom_write_byte(TEST_WRITE_PAGE * EEPROM_PAGE_SIZE, buffer[0]); success = is_eeprom_page_equal_to_buffer(TEST_WRITE_PAGE, buffer); test_assert_true(test, success, "Byte write failed"); }
void menu_main(void) { for(int i = 0; i < 4; i++) { CMD_buffer[i] = tolower(CMD_buffer[i]); } if (CMD_buffer[0] == 'v' && CMD_buffer[1] == 'x') { switch(CMD_buffer[2]) { case 'i': //information usb_tx_string_P(PSTR("Vehicle to Everything (V2X) RVI Node 2016\rOpen source hardware and software\rHW Rev1.2 \rSW Rev0.1\r")); break; case 'j': //Jaguar usb_tx_string_P(PSTR("\r\r ,ggp@@@@mgg,,\r,$Q$(`S@@$;g$$$$$@$@@gg,\r;gP'$@gg)$$@@$@@@$(L$$||$$@g,\r `g$P` ``*%@@@P`)Eg|||lLLL||$Bgg,\r ` ,gg$$@gg,`$..``$Z$$$$$EB$$@g,\r @P`pgg$$$||`)gggg;,, |$$$|$$$@g,\r 9w& '*^^` ``*P#9BB00000$$$@|`$$$g|Sg,\r *$@@L ```T$W~)%g,\r *%@gg,,,,, 5/Sw, ,\r ```` ` `9g `9g,``*^|'\r `#g,`)h\r\r Developed at Jaguar Land Rover OSCT. Portland OR 2016\r")); break; case 'q': menu_status(); break; case 'r': //reset reset_trigger_SYSTEM(); break; case 'a': //accel menu_accel(); break; case 'c': //CAN interface menu_can(); break; case 'm': //modem menu_modem(); break; case 'p': //power menu_power(); break; case 't': //timer functions menu_timer(); break; case 'v': //toggle verbose setting verbose = !verbose; nvm_eeprom_write_byte(EE_verbose,verbose); usb_tx_string_PV(PSTR("Verbose is ON")); break; case '?': //timer functions default: usb_tx_string_P(PSTR("*** Main Menu ***\rI: Device information\rA: Accelerometer menu(ACL)\rC: ELM327 menu(CAN)\rM: SIM Modem menu(GSM)\rP: Power menu\rT: Timer menu\rQ: Query system status\rV: Toggle verbose messages\rR: Reboot\r")); break; } } else { usb_tx_string_PV(PSTR("All commands start VX\r")); } clear_buffer(CMD_buffer); //clear the buffer for next command menu_send_n_st(); }
/** * Test nvm_eeprom_erase_page() and nvm_eeprom_write_byte(). * * Test procedure: * - Erase TEST_WRITE_PAGE * - Write one byte * - Verify that the byte is written and that all other bytes are erased. * * \return STATUS_OK if test succeeded, otherwise ERR_BAD_DATA */ static status_code_t test_write(void) { // Test write nvm_eeprom_erase_page(TEST_WRITE_PAGE); set_buffer(buffer, EEPROM_ERASED); buffer[0] = 0xaa; nvm_eeprom_write_byte(TEST_WRITE_PAGE*EEPROM_PAGE_SIZE, buffer[0]); if (is_eeprom_page_equal_to_buffer(TEST_WRITE_PAGE, buffer)) { return STATUS_OK; } return ERR_BAD_DATA; }
/** * \brief Test EEPROM byte erase * * This test writes two bytes to test pages \ref TEST_ERASE_BYTES_PAGE_1 and * \ref TEST_ERASE_BYTES_PAGE_2, then tries to erase one of them in the first * page before verifying the erase, then in all pages before verifying that the * second page was also erased. * * \param test Current test case. */ static void run_eeprom_erase_byte_test(const struct test_case *test) { uint8_t buffer[EEPROM_PAGE_SIZE]; bool success; set_buffer(buffer, EEPROM_ERASED); buffer[0] = 0xaa; buffer[1] = 0xaf; /* Write two bytes into first page */ nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_1 * EEPROM_PAGE_SIZE + 0, buffer[0]); nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_1 * EEPROM_PAGE_SIZE + 1, buffer[1]); /* Write two bytes into second page */ nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_2 * EEPROM_PAGE_SIZE + 0, buffer[0]); nvm_eeprom_write_byte(TEST_ERASE_BYTES_PAGE_2 * EEPROM_PAGE_SIZE + 1, buffer[1]); /* Erase first byte of the first page */ nvm_eeprom_load_byte_to_buffer(0, 0xff); nvm_eeprom_erase_bytes_in_page(TEST_ERASE_BYTES_PAGE_1); buffer[0] = EEPROM_ERASED; success = is_eeprom_page_equal_to_buffer(TEST_ERASE_BYTES_PAGE_1, buffer); test_assert_true(test, success, "Byte erase in single page failed"); /* Erase first byte of all pages */ nvm_eeprom_load_byte_to_buffer(0, 0xff); nvm_eeprom_erase_bytes_in_all_pages(); success = is_eeprom_page_equal_to_buffer(TEST_ERASE_BYTES_PAGE_2, buffer); test_assert_true(test, success, "Byte erase in all pages failed"); }
/** * \brief Write buffer within the eeprom * * \param address the address to where to write * \param buf pointer to the data * \param len the number of bytes to write */ void nvm_eeprom_erase_and_write_buffer(eeprom_addr_t address, const void *buf, uint16_t len) { while (len) { if (((address%EEPROM_PAGE_SIZE)==0) && (len>=EEPROM_PAGE_SIZE)) { // A full page can be written nvm_eeprom_load_page_to_buffer((uint8_t*)buf); nvm_eeprom_atomic_write_page(address/EEPROM_PAGE_SIZE); address += EEPROM_PAGE_SIZE; buf = (uint8_t*)buf + EEPROM_PAGE_SIZE; len -= EEPROM_PAGE_SIZE; } else { nvm_eeprom_write_byte(address++, *(uint8_t*)buf); buf = (uint8_t*)buf + 1; len--; } } }