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
}
