void system_config_init(void) { struct nvm_device_serial device_serial; nvm_read_device_serial(&device_serial); for(uint8_t x = 0; x < sizeof(device_serial); x++) sprintf((char *) serial_number + (2 * x), "%02X", device_serial.byte[x]); nvm_eeprom_read_buffer((eeprom_addr_t) &EEPROM_PDICLOCK, &(systemconfig.pdiclock), sizeof(EEPROM_PDICLOCK)); nvm_eeprom_read_buffer((eeprom_addr_t) &EEPROM_TPICLOCK, &(systemconfig.tpiclock), sizeof(EEPROM_TPICLOCK)); nvm_eeprom_read_buffer((eeprom_addr_t) &EEPROM_VERSION, &(systemconfig.version), sizeof(EEPROM_VERSION)); nvm_eeprom_read_buffer((eeprom_addr_t) &EEPROM_DRIVER, &(systemconfig.driver), sizeof(EEPROM_DRIVER)); system_config_check(); }
/** * \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"); }
status_code_t nvm_read(mem_type_t mem, uint32_t address, void *buffer, uint32_t len) { switch (mem) { case INT_FLASH: nvm_flash_read_buffer((flash_addr_t)address, buffer, (uint16_t)len); break; case INT_USERPAGE: nvm_user_sig_read_buffer((flash_addr_t)address, buffer, (uint16_t)len); break; case INT_EEPROM: nvm_eeprom_read_buffer((eeprom_addr_t)address, buffer, (uint16_t)len); break; #if defined(USE_EXTMEM) && defined(CONF_BOARD_AT45DBX) case AT45DBX: { uint32_t sector = address / AT45DBX_SECTOR_SIZE; if (!at45dbx_read_sector_open(sector)) { return ERR_BAD_ADDRESS; } at45dbx_read_sector_to_ram(buffer); at45dbx_read_close(); } break; #endif default: return ERR_INVALID_ARG; } return STATUS_OK; }
/** * \brief Copy a eeprom memory section to a RAM buffer * * \param dst Pointer to data destination. * \param src Pointer to source flash. * \param nbytes Number of bytes to transfer. */ static void mem_eeprom_read(void *dst, isp_addr_t src, uint16_t nbytes) { nvm_eeprom_read_buffer( src, dst, nbytes ); }
// Supporting function implementation Motors::Motors() { // Set mode mode = ABSOLUTE; // Set current values currentX = NAN; currentY = NAN; currentZ = NAN; currentE = NAN; currentF = NAN; // Check if last Z value was recorded if(nvm_eeprom_read_byte(EEPROM_SAVED_Z_STATE_OFFSET)) // Set current Z to last recorded Z value nvm_eeprom_read_buffer(EEPROM_LAST_RECORDED_Z_VALUE_OFFSET, ¤tZ, EEPROM_LAST_RECORDED_Z_VALUE_LENGTH); // Otherwise else // Set current Z to not a number currentZ = NAN; // Configure motors ioport_set_pin_dir(MOTORS_ENABLE_PIN, IOPORT_DIR_OUTPUT); ioport_set_pin_level(MOTORS_ENABLE_PIN, IOPORT_PIN_LEVEL_HIGH); ioport_set_pin_dir(MOTORS_STEP_CONTROL_PIN, IOPORT_DIR_OUTPUT); ioport_set_pin_level(MOTORS_STEP_CONTROL_PIN, IOPORT_PIN_LEVEL_LOW); // Configure motor X Vref, direction, and step ioport_set_pin_dir(MOTOR_X_VREF_PIN, IOPORT_DIR_OUTPUT); pwm_init(&motorXVrefPwm, MOTOR_X_VREF_PWM_TIMER, MOTOR_X_VREF_PWM_CHANNEL, 5000); pwm_start(&motorXVrefPwm, 0); ioport_set_pin_dir(MOTOR_X_DIRECTION_PIN, IOPORT_DIR_OUTPUT); ioport_set_pin_level(MOTOR_X_DIRECTION_PIN, IOPORT_PIN_LEVEL_HIGH); ioport_set_pin_dir(MOTOR_X_STEP_PIN, IOPORT_DIR_OUTPUT); pwm_config motorXStepPwm; pwm_init(&motorXStepPwm, MOTOR_X_STEP_PWM_TIMER, MOTOR_X_STEP_PWM_CHANNEL, 5000); pwm_start(&motorXStepPwm, 50); // Configure motor Y Vref, direction, and step ioport_set_pin_dir(MOTOR_Y_VREF_PIN, IOPORT_DIR_OUTPUT); pwm_init(&motorYVrefPwm, MOTOR_Y_VREF_PWM_TIMER, MOTOR_Y_VREF_PWM_CHANNEL, 5000); pwm_start(&motorYVrefPwm, 0); ioport_set_pin_dir(MOTOR_Y_DIRECTION_PIN, IOPORT_DIR_OUTPUT); ioport_set_pin_level(MOTOR_Y_DIRECTION_PIN, IOPORT_PIN_LEVEL_LOW); ioport_set_pin_dir(MOTOR_Y_STEP_PIN, IOPORT_DIR_OUTPUT); pwm_config motorYStepPwm; pwm_init(&motorYStepPwm, MOTOR_Y_STEP_PWM_TIMER, MOTOR_Y_STEP_PWM_CHANNEL, 5000); pwm_start(&motorYStepPwm, 50); // Configure motor Z VREF, direction, and step ioport_set_pin_dir(MOTOR_Z_VREF_PIN, IOPORT_DIR_OUTPUT); pwm_init(&motorZVrefPwm, MOTOR_Z_VREF_PWM_TIMER, MOTOR_Z_VREF_PWM_CHANNEL, 5000); pwm_start(&motorZVrefPwm, 0); ioport_set_pin_dir(MOTOR_Z_DIRECTION_PIN, IOPORT_DIR_OUTPUT); ioport_set_pin_level(MOTOR_Z_DIRECTION_PIN, IOPORT_PIN_LEVEL_LOW); ioport_set_pin_dir(MOTOR_Z_STEP_PIN, IOPORT_DIR_OUTPUT); pwm_config motorZStepPwm; pwm_init(&motorZStepPwm, MOTOR_Z_STEP_PWM_TIMER, MOTOR_Z_STEP_PWM_CHANNEL, 5000); pwm_start(&motorZStepPwm, 50); // Configure motor E VREF, direction, step, and AISEN ioport_set_pin_dir(MOTOR_E_VREF_PIN, IOPORT_DIR_OUTPUT); pwm_init(&motorEVrefPwm, MOTOR_E_VREF_PWM_TIMER, MOTOR_E_VREF_PWM_CHANNEL, 5000); pwm_start(&motorEVrefPwm, 0); ioport_set_pin_dir(MOTOR_E_DIRECTION_PIN, IOPORT_DIR_OUTPUT); ioport_set_pin_level(MOTOR_E_DIRECTION_PIN, IOPORT_PIN_LEVEL_LOW); ioport_set_pin_dir(MOTOR_E_STEP_PIN, IOPORT_DIR_OUTPUT); pwm_config motorEStepPwm; pwm_init(&motorEStepPwm, MOTOR_E_STEP_PWM_TIMER, MOTOR_E_STEP_PWM_CHANNEL, 5000); pwm_start(&motorEStepPwm, 50); ioport_set_pin_dir(MOTOR_E_AISEN_PIN, IOPORT_DIR_INPUT); ioport_set_pin_mode(MOTOR_E_AISEN_PIN, IOPORT_MODE_PULLDOWN); }
int main (void) { /* Insert system clock initialization code here (sysclk_init()). */ board_init(); sysclk_init(); ioport_init(); /* Insert application code here, after the board has been initialized. */ //Own variables bool running = true; bool error = false; uint8_t spi_counter = 0; //Testdata uint32_t testdata = 0; //Create command & data storage uint8_t commandUSART[NUMBER_CTRL_BYTES]; uint8_t commandSPI[NUMBER_CTRL_BYTES]; //Memory uint8_t write_page[EEPROM_PAGE_SIZE]; uint8_t read_page[EEPROM_PAGE_SIZE]; //Own inits init_led_pins(); //Boot sequence initiated switch_led(BOOT, true); init_usart_driver(PIN3_bm, PIN2_bm, &USART_data_Stepper, &USARTD0); init_usart_driver(PIN3_bm, PIN2_bm, &USART_data_PreAmp, &USARTC0); //Test blinking for(int i = 0; i < 10; i++) { blink_led(BOOT, 100); blink_led(RUNNING, 50); blink_led(RXTX, 50); blink_led(FAILURE, 100); blink_led(RXTX, 50); blink_led(RUNNING, 50); } //Load Stuff from memory, no clue what I should load memset(read_page, 0x0, EEPROM_PAGE_SIZE); nvm_eeprom_read_buffer(POSITION_ADDR, read_page, EEPROM_PAGE_SIZE); testdata = ((uint32_t)read_page[3] << 24) | ((uint32_t)read_page[2] << 16) | ((uint32_t)read_page[1] << 8) | read_page[0]; memset(read_page, 0x0, EEPROM_PAGE_SIZE); nvm_eeprom_read_buffer(SPEED_ADDR, read_page, EEPROM_PAGE_SIZE); //currentSpeed = ((uint32_t)read_page[0] << 24) | ((uint32_t)read_page[1] << 16) | ((uint32_t)read_page[2] << 8) | read_page[3]; memset(read_page, 0x0, EEPROM_PAGE_SIZE); //Boot sequence finished switch_led(BOOT, false); //Test of data if(testdata != 3) { switch_led(RXTX, true); //testdata = 10; } else switch_led(RUNNING, true); delay_ms(1000); testdata = 3; //End of test data; if(error != true) { memset(write_page, 0x0, EEPROM_PAGE_SIZE); write_page[3] = testdata >> 24; write_page[2] = testdata >> 16; write_page[1] = testdata >> 8; write_page[0] = testdata; nvm_eeprom_load_page_to_buffer(write_page); nvm_eeprom_atomic_write_page(POSITION_ADDR); memset(write_page, 0x0, EEPROM_PAGE_SIZE); write_page[3] = testdata >> 24; write_page[2] = testdata >> 16; write_page[1] = testdata >> 8; write_page[0] = testdata; nvm_eeprom_load_page_to_buffer(write_page); nvm_eeprom_atomic_write_page(POSITION_ADDR); memset(write_page, 0x0, EEPROM_PAGE_SIZE); switch_led(RUNNING, false); switch_led(RXTX, true); switch_led(BOOT, true); //Shutdown procedure can be executed }