int ff_cre_syncobj ( /* TRUE:Function succeeded, FALSE:Could not create due to any error */
BYTE vol, /* Corresponding logical drive being processed */
_SYNC_t *sobj /* Pointer to return the created sync object */
)
{
int ret;
*sobj = xSemaphoreCreateMutex(); /* FreeRTOS */
ret = (*sobj != NULL) ? __true : __false;
// Optional: Provide names of the FreeRTOS objects for the Trace Facility
vTraceSetMutexName(*sobj, "FATFS Mutex");
return ret;
}
/**
* Only task configured to start at boot; starts the rest of RTOS.
* We use this task to do most of the startup because it allows
* use of various RTOS functionality (which can cause issues when used
* before the scheduler is running).
* WARNING: The vApplicationDaemonTaskStartupHook did not work for us.
*/
void startup_task(void* pvParameters) {
print("EQUiSatOS starting... ");
#ifdef WRITE_DEFAULT_MRAM_VALS
// utility function to write initial state to MRAM (ONCE before launch)
write_custom_state();
#endif
/************************************************************************/
/* DATA INITIALIZATION */
/************************************************************************/
// Initialize misc. state mutexes
hardware_state_mutex = xSemaphoreCreateMutexStatic(&_hardware_state_mutex_d);
critical_action_mutex = xSemaphoreCreateMutexStatic(&_critical_action_mutex_d);
// Initialize EQUiStack mutexes
_idle_equistack_mutex = xSemaphoreCreateMutexStatic(&_idle_equistack_mutex_d);
_attitude_equistack_mutex = xSemaphoreCreateMutexStatic(&_attitude_equistack_mutex_d);
_flash_equistack_mutex = xSemaphoreCreateMutexStatic(&_flash_equistack_mutex_d);
_flash_cmp_equistack_mutex = xSemaphoreCreateMutexStatic(&_flash_cmp_equistack_mutex_d);
_low_power_equistack_mutex = xSemaphoreCreateMutexStatic(&_low_power_equistack_mutex_d);
// Initialize EQUiStacks
equistack_Init(&idle_readings_equistack, &_idle_equistack_arr,
sizeof(idle_data_t), IDLE_STACK_MAX, _idle_equistack_mutex);
equistack_Init(&attitude_readings_equistack, &_attitude_equistack_arr,
sizeof(attitude_data_t), ATTITUDE_STACK_MAX, _attitude_equistack_mutex);
equistack_Init(&flash_readings_equistack, &_flash_equistack_arr,
sizeof(flash_data_t), FLASH_STACK_MAX, _flash_equistack_mutex);
equistack_Init(&flash_cmp_readings_equistack, &_flash_cmp_equistack_arr,
sizeof(flash_cmp_data_t), FLASH_CMP_STACK_MAX, _flash_cmp_equistack_mutex);
equistack_Init(&low_power_readings_equistack, &_low_power_equistack_arr,
sizeof(low_power_data_t), LOW_POWER_STACK_MAX, _low_power_equistack_mutex);
/************************************************************************/
/* ESSENTIAL INITIALIZATION */
/************************************************************************/
// read state from MRAM for first time
// this initializes the error equistacks, so make sure no errors
// are logged before this (they shouldn't be before RTOS is started...)
configure_state_from_reboot();
// function in global to init things that use RTOS
// (MUST be done after config state from reboot)
global_init_post_rtos();
// populate task_handles array and setup constants
pre_init_rtos_tasks();
#if configUSE_TRACE_FACILITY == 1
// name mutexes
vTraceSetMutexName(critical_action_mutex, "CA");
vTraceSetMutexName(i2c_irpow_mutex, "I2C");
vTraceSetMutexName(irpow_semaphore, "IRPOW");
vTraceSetMutexName(processor_adc_mutex, "ADC");
vTraceSetMutexName(hardware_state_mutex, "HWST");
vTraceSetMutexName(watchdog_mutex, "WD");
vTraceSetMutexName(mram_spi_cache_mutex, "SPI");
vTraceSetMutexName(_idle_equistack_mutex, "eqIDLE");
vTraceSetMutexName(_attitude_equistack_mutex, "eqATT");
vTraceSetMutexName(_flash_equistack_mutex , "eqF_BST");
vTraceSetMutexName(_flash_cmp_equistack_mutex, "eqF_CMP");
vTraceSetMutexName(_low_power_equistack_mutex, "eqLP");
vTraceSetMutexName(_error_equistack_mutex, "eqERR");
#endif
// note RTOS is ready for watchdog callback, and log error if it already tripped
rtos_ready = true;
if (got_early_warning_callback_in_boot) {
log_error(ELOC_WATCHDOG, ECODE_WATCHDOG_EARLY_WARNING, true);
}
/************************************************************************/
/* TASK CREATION */
/************************************************************************/
// NOTE: We can't actually set task state before they are started below,
// and tasks start as active (resumed), so we have the tasks themselves
// call the function below which will either suspend them or leave them
// running as defined by the configuration of initial state.
// suspend the scheduler while adding tasks so their task handles
// are non-null when they start executing (i.e. they can be controlled)
pet_watchdog(); // in case this takes a bit and we're close
vTaskSuspendAll();
/************************************************************************/
/* TESTING/MISC */
/************************************************************************/
create_testing_tasks();
/************************************************************************/
/* END TESTING */
/************************************************************************/
#ifndef ONLY_RUN_TESTING_TASKS
battery_charging_task_handle = xTaskCreateStatic(battery_charging_task,
"battery charging action task",
TASK_BATTERY_CHARGING_STACK_SIZE,
NULL,
TASK_BATTERY_CHARGING_PRIORITY,
battery_charging_task_stack,
&battery_charging_task_buffer);
antenna_deploy_task_handle = xTaskCreateStatic(antenna_deploy_task,
"antenna deploy action task",
TASK_ANTENNA_DEPLOY_STACK_SIZE,
NULL,
TASK_ANTENNA_DEPLOY_PRIORITY,
antenna_deploy_task_stack,
&antenna_deploy_task_buffer);
state_handling_task_handle = xTaskCreateStatic(state_handling_task,
"state handling action task",
TASK_STATE_HANDLING_STACK_SIZE,
NULL,
TASK_STATE_HANDLING_PRIORITY,
state_handling_task_stack,
&state_handling_task_buffer);
watchdog_task_handle = xTaskCreateStatic(watchdog_task,
"watchdog task",
TASK_WATCHDOG_STACK_SIZE,
NULL,
TASK_WATCHDOG_PRIORITY,
watchdog_task_stack,
&watchdog_task_buffer);
persistent_data_backup_task_handle = xTaskCreateStatic(persistent_data_backup_task,
"persistent data backup task",
TASK_PERSISTENT_DATA_BACKUP_STACK_SIZE,
NULL,
TASK_PERSISTENT_DATA_BACKUP_PRIORITY,
persistent_data_backup_task_stack,
&persistent_data_backup_task_buffer);
flash_activate_task_handle = xTaskCreateStatic(flash_activate_task,
"flash action task",
TASK_FLASH_ACTIVATE_STACK_SIZE,
NULL,
TASK_FLASH_ACTIVATE_PRIORITY,
flash_activate_task_stack,
&flash_activate_task_buffer);
transmit_task_handle = xTaskCreateStatic(transmit_task,
"transmit action task",
TASK_TRANSMIT_STACK_SIZE,
NULL,
TASK_TRANSMIT_PRIORITY,
transmit_task_stack,
&transmit_task_buffer);
/* Data tasks */
idle_data_task_handle = xTaskCreateStatic(idle_data_task,
"idle data reader task",
TASK_IDLE_DATA_RD_STACK_SIZE,
NULL,
TASK_IDLE_DATA_RD_PRIORITY,
idle_data_task_stack,
&idle_data_task_buffer);
attitude_data_task_handle = xTaskCreateStatic(attitude_data_task,
"attitude data reader task",
TASK_ATTITUDE_DATA_RD_STACK_SIZE,
NULL,
TASK_ATTITUDE_DATA_DATA_RD_PRIORITY,
attitude_data_task_stack,
&attitude_data_task_buffer);
low_power_data_task_handle = xTaskCreateStatic(low_power_data_task,
"low power data reader task",
TASK_LOW_POWER_DATA_RD_STACK_SIZE,
NULL,
TASK_LOW_POWER_DATA_RD_PRIORITY,
low_power_data_task_stack,
&low_power_data_task_buffer);
#endif
xTaskResumeAll();
setTXEnable(false);
usart_send_string((uint8_t*) "EQUiSatOS started");
setTXEnable(true);
print("initialization complete.\n");
// delete this task after it's done booting
vTaskDelete(NULL);
}
