datalogger.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DATALOGGER_MODULE_ENABLED   1
#define	DATALOGGER_DEBUG_MODE   0
#define	DATALOGGER_ENABLE_NEW_FILE_ENNUMERATION   0
#define	DATALOGGER_FILE_NAME   "rleg"
#define	DATALOGGER_FOLDER   "matlabdatafiles"
#define	DATALOGGER_STANDARD_QUEUE_SIZE   750
#define	DATALOGGER_LOG_TIME   1
#define	DATALOGGER_LOG_EXECTIMES   1
#define	DATALOGGER_LOG_RAW_IMU   1
#define	DATALOGGER_LOG_EFFORTS   1
#define	DATALOGGER_LOG_MRA   1
#define	DATALOGGER_LOG_CALIBRATED_IMU   1
#define	DATALOGGER_NOT_INITIALIZED   0
#define	DATALOGGER_INITIALIZED   1
#define	DATALOGGER_NOT_RUNNING   0
#define	DATALOGGER_RUNNING   1
#define	DATALOGGER_VARIABLE_NOT_INSERTED   0
#define	DATALOGGER_VARIABLE_INSERTED   1
#define	DATALOGGER_SUCCESS   1
#define	DATALOGGER_FAILURE   -1
#define	DATALOGGER_ERROR_NOT_INITIALIZED   -2
#define	DATALOGGER_VARIBALE_ALREADY_INSERTED   -3

Functions
int	datalogger_init (void)
int	datalogger_close (void)
int	datalogger_write_file (void)
int	datalogger_update_IPC (void)
int	datalogger_update (double t_s, double t_control_exec_s, double t_ui_exec_s, double t0_s, IMU_DATA_STRUCT *pimu_data, EFF_DATA_STRUCT *peff_data, MRA_DATA_STRUCT *pmra_data)
int	datalogger_set_Ts (double Ts)
int	datalogger_status (void)
int	datalogger_start (void)
int	datalogger_stop (void)
int	datalogger_file_exists (const char *filename)

Macro Definition Documentation

#define DATALOGGER_DEBUG_MODE   0

Definition at line 6 of file datalogger.h.

#define DATALOGGER_ENABLE_NEW_FILE_ENNUMERATION   0

Definition at line 9 of file datalogger.h.

#define DATALOGGER_ERROR_NOT_INITIALIZED   -2

Definition at line 37 of file datalogger.h.

Referenced by datalogger_close(), datalogger_set_Ts(), datalogger_start(), datalogger_status(), datalogger_stop(), datalogger_update(), datalogger_update_IPC(), and datalogger_write_file().

#define DATALOGGER_FAILURE   -1

Definition at line 36 of file datalogger.h.

Referenced by datalogger_file_exists(), and datalogger_init().

#define DATALOGGER_FILE_NAME   "rleg"

Definition at line 10 of file datalogger.h.

Referenced by datalogger_init().

#define DATALOGGER_FOLDER   "matlabdatafiles"

Definition at line 11 of file datalogger.h.

Referenced by datalogger_init().

#define DATALOGGER_INITIALIZED   1

Definition at line 28 of file datalogger.h.

Referenced by datalogger_close(), datalogger_init(), datalogger_set_Ts(), datalogger_start(), datalogger_status(), datalogger_stop(), datalogger_update(), datalogger_update_IPC(), and datalogger_write_file().

#define DATALOGGER_LOG_CALIBRATED_IMU   1

Definition at line 22 of file datalogger.h.

Referenced by datalogger_init().

#define DATALOGGER_LOG_EFFORTS   1

Definition at line 18 of file datalogger.h.

Referenced by datalogger_init().

#define DATALOGGER_LOG_EXECTIMES   1

Definition at line 16 of file datalogger.h.

Referenced by datalogger_init().

#define DATALOGGER_LOG_MRA   1

Definition at line 19 of file datalogger.h.

Referenced by datalogger_init().

#define DATALOGGER_LOG_RAW_IMU   1

Definition at line 17 of file datalogger.h.

Referenced by datalogger_init().

#define DATALOGGER_LOG_TIME   1

Definition at line 15 of file datalogger.h.

Referenced by datalogger_init().

#define DATALOGGER_MODULE_ENABLED   1

Definition at line 5 of file datalogger.h.

#define DATALOGGER_NOT_INITIALIZED   0

Definition at line 27 of file datalogger.h.

Referenced by datalogger_close().

#define DATALOGGER_NOT_RUNNING   0

Definition at line 29 of file datalogger.h.

Referenced by control_task(), datalogger_init(), datalogger_stop(), periodic_task_1(), threads_linux_periodic_task_1(), and ui_overview_data().

#define DATALOGGER_RUNNING   1

Definition at line 30 of file datalogger.h.

Referenced by control_task(), datalogger_start(), main(), periodic_task_1(), threads_linux_init(), threads_linux_periodic_task_1(), and ui_update().

#define DATALOGGER_STANDARD_QUEUE_SIZE   750

Definition at line 12 of file datalogger.h.

Referenced by datalogger_init().

#define DATALOGGER_SUCCESS   1

Definition at line 35 of file datalogger.h.

Referenced by datalogger_close(), datalogger_file_exists(), datalogger_init(), datalogger_lock_mutex(), datalogger_set_Ts(), datalogger_start(), datalogger_stop(), datalogger_unlock_mutex(), datalogger_update(), datalogger_update_IPC(), datalogger_write_file(), main(), and threads_linux_init().

#define DATALOGGER_VARIABLE_INSERTED   1

Definition at line 32 of file datalogger.h.

Referenced by datalogger_set_Ts().

#define DATALOGGER_VARIABLE_NOT_INSERTED   0

Definition at line 31 of file datalogger.h.

Referenced by datalogger_set_Ts().

#define DATALOGGER_VARIBALE_ALREADY_INSERTED   -3

Definition at line 38 of file datalogger.h.

Referenced by datalogger_set_Ts().

Function Documentation

int datalogger_close

(

void

)

Definition at line 215 of file datalogger.c.

References DATALOGGER_ERROR_NOT_INITIALIZED, DATALOGGER_INITIALIZED, datalogger_initialized, datalogger_lock_mutex(), datalogger_mutex, DATALOGGER_NOT_INITIALIZED, DATALOGGER_SUCCESS, datalogger_unlock_mutex(), gDataLogger_Close(), and gDataLogger_MatfileUpdate().

Referenced by main(), and threads_linux_init().

{
    #if DATALOGGER_MODULE_ENABLED
        datalogger_lock_mutex();
        if(datalogger_initialized != DATALOGGER_INITIALIZED)
    {
            datalogger_unlock_mutex();
        return DATALOGGER_ERROR_NOT_INITIALIZED;
    }

    gDataLogger_MatfileUpdate(&gDataLogger); // Update data
    gDataLogger_Close(&gDataLogger); // Close datalogger

    datalogger_initialized = DATALOGGER_NOT_INITIALIZED;
    datalogger_unlock_mutex();

        #if ANU_COMPILE_FOR_XENOMAI
    rt_mutex_delete(&datalogger_mutex);
        #endif  //ANU_COMPILE_FOR_XENOMAI

    #endif //DATALOGGER_MODULE_ENABLED

    return DATALOGGER_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int datalogger_file_exists

(

const char *

filename

)

Definition at line 618 of file datalogger.c.

References DATALOGGER_FAILURE, and DATALOGGER_SUCCESS.

Referenced by datalogger_init().

{
    FILE *file;
    if((file = fopen(filename, "r")))
    {
        fclose(file);
        return DATALOGGER_SUCCESS;
    }
    return DATALOGGER_FAILURE;
}

Here is the caller graph for this function:

int datalogger_init

(

void

)

Definition at line 41 of file datalogger.c.

References DATALOGGER_FAILURE, datalogger_file_exists(), DATALOGGER_FILE_NAME, DATALOGGER_FOLDER, DATALOGGER_INITIALIZED, datalogger_initialized, datalogger_lock_mutex(), DATALOGGER_LOG_CALIBRATED_IMU, DATALOGGER_LOG_EFFORTS, DATALOGGER_LOG_EXECTIMES, DATALOGGER_LOG_MRA, DATALOGGER_LOG_RAW_IMU, DATALOGGER_LOG_TIME, datalogger_mutex, DATALOGGER_NOT_RUNNING, datalogger_running, DATALOGGER_STANDARD_QUEUE_SIZE, DATALOGGER_SUCCESS, datalogger_unlock_mutex(), gDataLogger_DeclareVariable(), gDataLogger_Init(), and gDataLogger_InsertVariable().

Referenced by main(), and threads_linux_init().

{
    #if DATALOGGER_MODULE_ENABLED
    double enabled_variables[16][1];
    char datalogger_filename[256];
        #if ANU_COMPILE_FOR_XENOMAI
    rt_mutex_create(&datalogger_mutex,"Data Logger Mutex");
        #endif
    datalogger_lock_mutex();

    if(datalogger_initialized == DATALOGGER_INITIALIZED)
    {
        datalogger_unlock_mutex();
        return DATALOGGER_FAILURE;
    }

    datalogger_running = DATALOGGER_NOT_RUNNING;

        // Init datalogger
    strcpy(datalogger_filename, DATALOGGER_FOLDER);
    strcat(datalogger_filename, "/");
    strcat(datalogger_filename, DATALOGGER_FILE_NAME);
    strcat(datalogger_filename, ".mat");
        #if DATALOGGER_ENABLE_NEW_FILE_ENNUMERATION
    char datalogger_tmp[256];
    int i = 0;
    if(datalogger_file_exists(datalogger_filename) == DATALOGGER_SUCCESS) // File exists
    {
        strcpy(datalogger_tmp, DATALOGGER_FOLDER);
        strcat(datalogger_tmp, "/");
        strcat(datalogger_tmp, DATALOGGER_FILE_NAME);
        strcat(datalogger_tmp, "_%d.mat");
        do
        {
            sprintf(datalogger_filename, datalogger_tmp, ++i);
        }
        while((datalogger_file_exists(datalogger_filename) == DATALOGGER_SUCCESS) && (i<100));
        if(i == 100)
        {
            datalogger_unlock_mutex();
            return DATALOGGER_FAILURE;
        }
    }
        #endif //DATALOGGER_ENABLE_NEW_FILE_ENNUMERATION

    if(!gDataLogger_Init(&gDataLogger, datalogger_filename, NULL))
    {
        datalogger_unlock_mutex();
        return DATALOGGER_FAILURE;
    }

        // Declare variables
        // Arguments for gDataLogger_DeclareVariable:
        // datalogger pointer, variable name, units, number of rows, number of columns, queue size

        // Variable that tells MATLAB which variables are enabled
    enabled_variables[0][0] = (double) DATALOGGER_LOG_TIME;
    enabled_variables[1][0] = (double) DATALOGGER_LOG_EXECTIMES;
    enabled_variables[2][0] = (double) DATALOGGER_LOG_RAW_IMU;
    enabled_variables[3][0] = (double) DATALOGGER_LOG_CALIBRATED_IMU;
    enabled_variables[4][0] = (double) DATALOGGER_LOG_EFFORTS;
    enabled_variables[5][0] = (double) DATALOGGER_LOG_MRA;
    //enabled_variables[12][0] = (double) DATALOGGER_LOG_LOCAL_COORDINATE_SYSTEM;
    //enabled_variables[13][0] = (double) DATALOGGER_LOG_LOCAL_FIELDS;
    //enabled_variables[14][0] = (double) DATALOGGER_LOG_ESTIMATOR;
    //enabled_variables[15][0] = (double) DATALOGGER_LOG_CONTROLLERS;

    gDataLogger_DeclareVariable(&gDataLogger, "enabled_vars", "", 6, 1, 1);
    gDataLogger_InsertVariable(&gDataLogger, "enabled_vars", &enabled_variables[0][0]);

        #if DATALOGGER_LOG_TIME
        gDataLogger_DeclareVariable(&gDataLogger, "t", "s", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "Ts", "s", 1, 1, 1);
    #endif // DATALOGGER_LOG_TIME

    #if DATALOGGER_LOG_EXECTIMES
    gDataLogger_DeclareVariable(&gDataLogger, "t_control_exec", "s", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "t_ui_exec", "s", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    #endif // DATALOGGER_LOG_EXECTIMES

        #if DATALOGGER_LOG_RAW_IMU
        gDataLogger_DeclareVariable(&gDataLogger, "imu_accelerometer_x_raw", "raw", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
        gDataLogger_DeclareVariable(&gDataLogger, "imu_accelerometer_y_raw", "raw", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
        gDataLogger_DeclareVariable(&gDataLogger, "imu_accelerometer_z_raw", "raw", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
        gDataLogger_DeclareVariable(&gDataLogger, "imu_magnetometer_x_raw", "raw", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
        gDataLogger_DeclareVariable(&gDataLogger, "imu_magnetometer_y_raw", "raw", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
        gDataLogger_DeclareVariable(&gDataLogger, "imu_magnetometer_z_raw", "raw", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
        gDataLogger_DeclareVariable(&gDataLogger, "imu_gyrometer_x_raw", "raw", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
        gDataLogger_DeclareVariable(&gDataLogger, "imu_gyrometer_y_raw", "raw", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
        gDataLogger_DeclareVariable(&gDataLogger, "imu_gyrometer_z_raw", "raw", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "imu_valid_data", "", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
        #endif // DATALOGGER_LOG_IMU
        
    #if DATALOGGER_LOG_EFFORTS
    gDataLogger_DeclareVariable(&gDataLogger, "Vin0", "mV", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "Vin0_valid_data", "", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    #endif
    
    #if DATALOGGER_LOG_MRA
    gDataLogger_DeclareVariable(&gDataLogger, "v_ctl", "mV", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "v_ctl_read", "mV", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    #endif

    #if DATALOGGER_LOG_CALIBRATED_IMU
    gDataLogger_DeclareVariable(&gDataLogger, "imu_accelerometer_x_g", "g", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "imu_accelerometer_y_g", "g", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "imu_accelerometer_z_g", "g", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "imu_magnetometer_x_B", "B", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "imu_magnetometer_y_B", "B", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "imu_magnetometer_z_B", "B", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "imu_gyrometer_x_rads", "rads", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "imu_gyrometer_y_rads", "rads", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "imu_gyrometer_z_rads", "rads", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "imu_calibrated_valid_data", "", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    //gDataLogger_DeclareVariable(&gDataLogger, "imu_calibrated_valid_accelerometer_data", "", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    //gDataLogger_DeclareVariable(&gDataLogger, "imu_calibrated_valid_gyrometer_data", "", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    //gDataLogger_DeclareVariable(&gDataLogger, "imu_calibrated_valid_magnetometer_data", "", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    #endif // DATALOGGER_LOG_CALIBRATED_IMU


/*
    #if DATALOGGER_LOG_LOCAL_COORDINATE_SYSTEM
    gDataLogger_DeclareVariable(&gDataLogger, "initial_altitude", "m", 1, 1, 1);
    gDataLogger_DeclareVariable(&gDataLogger, "initial_latitude", "radians", 1, 1, 1);
    gDataLogger_DeclareVariable(&gDataLogger, "initial_longitude", "radians", 1, 1, 1);
    gDataLogger_DeclareVariable(&gDataLogger, "initial_ecef_x", "m", 1, 1, 1);
    gDataLogger_DeclareVariable(&gDataLogger, "initial_ecef_y", "m", 1, 1, 1);
    gDataLogger_DeclareVariable(&gDataLogger, "initial_ecef_z", "m", 1, 1, 1);
    gDataLogger_DeclareVariable(&gDataLogger, "rotation_matrix", "matrix", 3, 3, 1);
    #endif // DATALOGGER_LOG_LOCAL_COORDINATE_SYSTEM

    #if DATALOGGER_LOG_LOCAL_FIELDS
    gDataLogger_DeclareVariable(&gDataLogger, "local_magnetic", "field", 3, 1, 1);
    gDataLogger_DeclareVariable(&gDataLogger, "local_gravity", "field", 3, 1, 1);
    gDataLogger_DeclareVariable(&gDataLogger, "magnetic_magnitude", "uT", 1, 1, 1);
    gDataLogger_DeclareVariable(&gDataLogger, "gravity_magnitude", "ms2", 1, 1, 1);
    #endif // DATALOGGER_LOG_LOCAL_FIELDS

    #if DATALOGGER_LOG_ESTIMATOR
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_roll_angle_radians", "radians", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_pitch_angle_radians", "radians", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_yaw_angle_radians", "radians", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_q0", "quaternion", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_q1", "quaternion", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_q2", "quaternion", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_q3", "quaternion", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_x_position_meters", "meters", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_y_position_meters", "meters", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_z_position_meters", "meters", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_x_velocity_meters_second", "meters", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_y_velocity_meters_second", "meters", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "estimated_z_velocity_meters_second", "meters", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    #endif // DATALOGGER_LOG_ESTIMATOR

    #if DATALOGGER_LOG_CONTROLLERS
    gDataLogger_DeclareVariable(&gDataLogger, "control_roll_angle_trim_radians", "radians", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "control_pitch_angle_trim_radians", "radians", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "control_yaw_angle_trim_radians", "radians", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "control_left_aileron_trim", "us", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "control_right_aileron_trim", "us", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "control_elevator_trim", "us", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "control_rudder_trim", "us", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "control_roll_angle_reference_radians", "radians", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "control_pitch_angle_reference_radians", "radians", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    gDataLogger_DeclareVariable(&gDataLogger, "control_yaw_angle_reference_radians", "radians", 1, 1, DATALOGGER_STANDARD_QUEUE_SIZE);
    #endif // DATALOGGER_LOG_CONTROLLERS
*/
    datalogger_initialized = DATALOGGER_INITIALIZED;
    datalogger_unlock_mutex();
    #endif //DATALOGGER_MODULE_ENABLED

    return DATALOGGER_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int datalogger_set_Ts

(

double

Ts

)

Definition at line 540 of file datalogger.c.

References DATALOGGER_ERROR_NOT_INITIALIZED, DATALOGGER_INITIALIZED, datalogger_initialized, datalogger_lock_mutex(), DATALOGGER_SUCCESS, datalogger_unlock_mutex(), DATALOGGER_VARIABLE_INSERTED, DATALOGGER_VARIABLE_NOT_INSERTED, DATALOGGER_VARIBALE_ALREADY_INSERTED, and gDataLogger_InsertVariable().

Referenced by control_task(), periodic_task_1(), and threads_linux_periodic_task_1().

{
    static int datalogger_Ts_inserted = DATALOGGER_VARIABLE_NOT_INSERTED;

    datalogger_lock_mutex();

    if(datalogger_initialized != DATALOGGER_INITIALIZED)
    {
        datalogger_unlock_mutex();
        return DATALOGGER_ERROR_NOT_INITIALIZED;
    }

    #if DATALOGGER_LOG_TIME
    if(datalogger_Ts_inserted == DATALOGGER_VARIABLE_NOT_INSERTED)
    {
        datalogger_Ts_inserted = DATALOGGER_VARIABLE_INSERTED;
        gDataLogger_InsertVariable(&gDataLogger, "Ts", &Ts);
    }
    else
        {
        datalogger_unlock_mutex();
        return DATALOGGER_VARIBALE_ALREADY_INSERTED;
        }
    #else
    double tmp = Ts; // Remove warning
    #endif // DATALOGGER_LOG_TIME

    datalogger_unlock_mutex();
    return DATALOGGER_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int datalogger_start

(

void

)

Definition at line 584 of file datalogger.c.

References DATALOGGER_ERROR_NOT_INITIALIZED, DATALOGGER_INITIALIZED, datalogger_initialized, datalogger_lock_mutex(), datalogger_running, DATALOGGER_RUNNING, DATALOGGER_SUCCESS, and datalogger_unlock_mutex().

Referenced by ui_update().

{
    #if DATALOGGER_MODULE_ENABLED
    datalogger_lock_mutex();
    if(datalogger_initialized != DATALOGGER_INITIALIZED)
    {
        datalogger_unlock_mutex();
        return DATALOGGER_ERROR_NOT_INITIALIZED;
    }

    datalogger_running = DATALOGGER_RUNNING;
    datalogger_unlock_mutex();
    #endif

    return DATALOGGER_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int datalogger_status

(

void

)

Definition at line 571 of file datalogger.c.

References DATALOGGER_ERROR_NOT_INITIALIZED, DATALOGGER_INITIALIZED, datalogger_initialized, datalogger_lock_mutex(), datalogger_running, and datalogger_unlock_mutex().

Referenced by control_task(), main(), periodic_task_1(), threads_linux_init(), threads_linux_periodic_task_1(), ui_overview_data(), and ui_update().

{
    datalogger_lock_mutex();
    if(datalogger_initialized != DATALOGGER_INITIALIZED)
    {
        datalogger_unlock_mutex();
        return DATALOGGER_ERROR_NOT_INITIALIZED;
    }

    datalogger_unlock_mutex();
    return datalogger_running;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int datalogger_stop

(

void

)

Definition at line 601 of file datalogger.c.

References DATALOGGER_ERROR_NOT_INITIALIZED, DATALOGGER_INITIALIZED, datalogger_initialized, datalogger_lock_mutex(), DATALOGGER_NOT_RUNNING, datalogger_running, DATALOGGER_SUCCESS, and datalogger_unlock_mutex().

Referenced by main(), and ui_update().

{
    #if DATALOGGER_MODULE_ENABLED
    datalogger_lock_mutex();
    if(datalogger_initialized != DATALOGGER_INITIALIZED)
    {
        datalogger_unlock_mutex();
        return DATALOGGER_ERROR_NOT_INITIALIZED;
    }

    datalogger_running = DATALOGGER_NOT_RUNNING;
    datalogger_unlock_mutex();
    #endif

    return DATALOGGER_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int datalogger_update	(	double	t_s,
		double	t_control_exec_s,
		double	t_ui_exec_s,
		double	t0_s,
		IMU_DATA_STRUCT *	pimu_data,
		EFF_DATA_STRUCT *	peff_data,
		MRA_DATA_STRUCT *	pmra_data
	)

Definition at line 272 of file datalogger.c.

References IMU_DATA_STRUCT::acc, IMU_DATA_STRUCT::calibrated::acc, IMU_DATA_STRUCT::calib, DATALOGGER_ERROR_NOT_INITIALIZED, DATALOGGER_INITIALIZED, datalogger_initialized, datalogger_lock_mutex(), DATALOGGER_SUCCESS, datalogger_unlock_mutex(), EFF_DATA_STRUCT::F, gDataLogger_InsertVariable(), IMU_DATA_STRUCT::gyr, IMU_DATA_STRUCT::calibrated::gyr, IMU_DATA_STRUCT::mag, IMU_DATA_STRUCT::calibrated::mag, IMU_DATA_STRUCT::new_data, EFF_DATA_STRUCT::new_data, MRA_DATA_STRUCT::v_ctl, MRA_DATA_STRUCT::v_ctl_read, DATA_XYZ::x, DATA_XYZ_DOUBLE::x, DATA_XYZ::y, DATA_XYZ_DOUBLE::y, DATA_XYZ::z, and DATA_XYZ_DOUBLE::z.

Referenced by control_task(), periodic_task_1(), and threads_linux_periodic_task_1().

{
    double tmp = 0.0;

    datalogger_lock_mutex();

    if(datalogger_initialized != DATALOGGER_INITIALIZED)
    {
        datalogger_unlock_mutex();
        return DATALOGGER_ERROR_NOT_INITIALIZED;
    }

    #if DATALOGGER_LOG_TIME
    double tmp_t = t_s - t0_s;
    gDataLogger_InsertVariable(&gDataLogger, "t", &tmp_t);
    #else
    double tmp_t = 0.0;
    tmp_t = t_s; // Remove warning
    #endif // DATALOGGER_LOG_TIME

    #if DATALOGGER_LOG_EXECTIMES
    gDataLogger_InsertVariable(&gDataLogger, "t_control_exec", &t_control_exec_s);
    gDataLogger_InsertVariable(&gDataLogger, "t_ui_exec", &t_ui_exec_s);
    #else
    double tmp_e = 0.0; // Remove warning
    tmp_e = t_control_exec_s; // Remove warning
    tmp_e = t_ui_exec_s; // Remove warning
    #endif // DATALOGGER_LOG_EXECTIMES


    #if DATALOGGER_LOG_RAW_IMU
    tmp = (double) pimu_data->acc.x;
    gDataLogger_InsertVariable(&gDataLogger, "imu_accelerometer_x_raw", &tmp);
    tmp = (double) pimu_data->acc.y;
    gDataLogger_InsertVariable(&gDataLogger, "imu_accelerometer_y_raw", &tmp);
    tmp = (double) pimu_data->acc.z;
    gDataLogger_InsertVariable(&gDataLogger, "imu_accelerometer_z_raw", &tmp);
    tmp = (double) pimu_data->mag.x;
    gDataLogger_InsertVariable(&gDataLogger, "imu_magnetometer_x_raw", &tmp);
    tmp = (double) pimu_data->mag.y;
    gDataLogger_InsertVariable(&gDataLogger, "imu_magnetometer_y_raw", &tmp);
    tmp = (double) pimu_data->mag.z;
    gDataLogger_InsertVariable(&gDataLogger, "imu_magnetometer_z_raw", &tmp);
    tmp = (double) pimu_data->gyr.x;
    gDataLogger_InsertVariable(&gDataLogger, "imu_gyrometer_x_raw", &tmp);
    tmp = (double) pimu_data->gyr.y;
    gDataLogger_InsertVariable(&gDataLogger, "imu_gyrometer_y_raw", &tmp);
    tmp = (double) pimu_data->gyr.z;
    gDataLogger_InsertVariable(&gDataLogger, "imu_gyrometer_z_raw", &tmp);
    tmp = (double) pimu_data->new_data;
    gDataLogger_InsertVariable(&gDataLogger, "imu_valid_data", &tmp);
    #else
    double tmp_ri = 0; // Remove warning
    tmp_ri = pimu_data->new_data; // Remove warning ???
    #endif //DATALOGGER_LOG_RAW_IMU
    
    #if DATALOGGER_LOG_EFFORTS
    tmp = (double) peff_data->F.x;
    gDataLogger_InsertVariable(&gDataLogger, "Vin0", &tmp);
    tmp = (double) peff_data->new_data;
    gDataLogger_InsertVariable(&gDataLogger, "Vin0_valid_data", &tmp);
    #endif
    
    #if DATALOGGER_LOG_MRA
    tmp = (double) pmra_data->v_ctl;
    gDataLogger_InsertVariable(&gDataLogger, "v_ctl", &tmp);
    tmp = (double) pmra_data->v_ctl_read;
    gDataLogger_InsertVariable(&gDataLogger, "v_ctl_read", &tmp);
    #endif
    
    
       
    #if DATALOGGER_LOG_CALIBRATED_IMU
    gDataLogger_InsertVariable(&gDataLogger, "imu_accelerometer_x_g", &(pimu_data->calib.acc.x));
    gDataLogger_InsertVariable(&gDataLogger, "imu_accelerometer_y_g", &(pimu_data->calib.acc.y));
    gDataLogger_InsertVariable(&gDataLogger, "imu_accelerometer_z_g", &(pimu_data->calib.acc.z));
    gDataLogger_InsertVariable(&gDataLogger, "imu_magnetometer_x_B", &(pimu_data->calib.mag.x));
    gDataLogger_InsertVariable(&gDataLogger, "imu_magnetometer_y_B", &(pimu_data->calib.mag.y));
    gDataLogger_InsertVariable(&gDataLogger, "imu_magnetometer_z_B", &(pimu_data->calib.mag.z));
    gDataLogger_InsertVariable(&gDataLogger, "imu_gyrometer_x_rads", &(pimu_data->calib.gyr.x));
    gDataLogger_InsertVariable(&gDataLogger, "imu_gyrometer_y_rads", &(pimu_data->calib.gyr.y));
    gDataLogger_InsertVariable(&gDataLogger, "imu_gyrometer_z_rads", &(pimu_data->calib.gyr.z));
    tmp = (double) pimu_data->new_data;
    gDataLogger_InsertVariable(&gDataLogger, "imu_calibrated_valid_data", &tmp);
    //tmp = pimu_measure->FlagValidAccerometerMeasure;
    //gDataLogger_InsertVariable(&gDataLogger, "imu_calibrated_valid_accelerometer_data", &tmp);
    //tmp = pimu_measure->FlagValidGyrometerMeasure;
    //gDataLogger_InsertVariable(&gDataLogger, "imu_calibrated_valid_gyrometer_data", &tmp);
    //tmp = pmagnetometer_measure->FlagValidMeasure;
    //gDataLogger_InsertVariable(&gDataLogger, "imu_calibrated_valid_magnetometer_data", &tmp);
    #else
    double tmp_ci = 0.0;
    tmp_ci = pimu_measure->ax; // Remove warning
    tmp_ci = pmagnetometer_measure->mx; // Remove warning
    #endif // DATALOGGER_LOG_CALIBRATED_IMU

 /*
    #if DATALOGGER_LOG_ESTIMATOR
    gDataLogger_InsertVariable(&gDataLogger, "estimated_roll_angle_radians", &(pestimation_data->roll_angle_radians));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_pitch_angle_radians", &(pestimation_data->pitch_angle_radians));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_yaw_angle_radians", &(pestimation_data->yaw_angle_radians));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_q0", &(pestimation_data->q0));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_q1", &(pestimation_data->q1));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_q2", &(pestimation_data->q2));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_q3", &(pestimation_data->q3));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_x_position_meters", &(pestimation_data->x_position_meters));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_y_position_meters", &(pestimation_data->y_position_meters));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_z_position_meters", &(pestimation_data->z_position_meters));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_x_velocity_meters_second", &(pestimation_data->x_velocity_meters_second));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_y_velocity_meters_second", &(pestimation_data->y_velocity_meters_second));
    gDataLogger_InsertVariable(&gDataLogger, "estimated_z_velocity_meters_second", &(pestimation_data->z_velocity_meters_second));
        #else
    double tmp_est = 0.0;
        tmp_est = pestimation_data->roll_angle_radians; // Remove warning
    #endif // DATALOGGER_LOG_ESTIMATOR

    #if DATALOGGER_LOG_CONTROLLERS
        gDataLogger_InsertVariable(&gDataLogger, "control_roll_angle_trim_radians", &(pcontrol_data->roll_angle_trim_radians));
        gDataLogger_InsertVariable(&gDataLogger, "control_pitch_angle_trim_radians", &(pcontrol_data->pitch_angle_trim_radians));
        gDataLogger_InsertVariable(&gDataLogger, "control_yaw_angle_trim_radians", &(pcontrol_data->yaw_angle_trim_radians));
        gDataLogger_InsertVariable(&gDataLogger, "control_left_aileron_trim", &(pcontrol_data->left_aileron_trim));
        gDataLogger_InsertVariable(&gDataLogger, "control_right_aileron_trim", &(pcontrol_data->right_aileron_trim));
        gDataLogger_InsertVariable(&gDataLogger, "control_elevator_trim", &(pcontrol_data->elevator_trim));
        gDataLogger_InsertVariable(&gDataLogger, "control_rudder_trim", &(pcontrol_data->rudder_trim));
        gDataLogger_InsertVariable(&gDataLogger, "control_roll_angle_reference_radians", &(pcontrol_data->roll_angle_reference_radians));
        gDataLogger_InsertVariable(&gDataLogger, "control_pitch_angle_reference_radians", &(pcontrol_data->pitch_angle_reference_radians));
        gDataLogger_InsertVariable(&gDataLogger, "control_yaw_angle_reference_radians", &(pcontrol_data->yaw_angle_reference_radians));
    #else
    double tmp_control = 0.0;
    tmp_control = pcontrol_data->roll_angle_trim_radians;
    #endif // DATALOGGER_LOG_CONTROLLERS
*/
    datalogger_unlock_mutex();

    return DATALOGGER_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int datalogger_update_IPC

(

void

)

Definition at line 256 of file datalogger.c.

References DATALOGGER_ERROR_NOT_INITIALIZED, DATALOGGER_INITIALIZED, datalogger_initialized, datalogger_lock_mutex(), DATALOGGER_SUCCESS, datalogger_unlock_mutex(), and gDataLogger_IPCUpdate().

Referenced by threads_linux_init().

{
    #if DATALOGGER_MODULE_ENABLED
    datalogger_lock_mutex();
    if(datalogger_initialized != DATALOGGER_INITIALIZED)
    {
        datalogger_unlock_mutex();
        return DATALOGGER_ERROR_NOT_INITIALIZED;
    }

    gDataLogger_IPCUpdate(&gDataLogger); // Manages IPC
    datalogger_unlock_mutex();
    #endif
    return DATALOGGER_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int datalogger_write_file

(

void

)

Definition at line 240 of file datalogger.c.

References DATALOGGER_ERROR_NOT_INITIALIZED, DATALOGGER_INITIALIZED, datalogger_initialized, datalogger_lock_mutex(), DATALOGGER_SUCCESS, datalogger_unlock_mutex(), and gDataLogger_MatfileUpdate().

Referenced by main(), and threads_linux_init().

{
    #if DATALOGGER_MODULE_ENABLED
    datalogger_lock_mutex();
    if(datalogger_initialized != DATALOGGER_INITIALIZED)
    {
        datalogger_unlock_mutex();
        return DATALOGGER_ERROR_NOT_INITIALIZED;
    }
    gDataLogger_MatfileUpdate(&gDataLogger); // Empty buffers in the file
    datalogger_unlock_mutex();
    #endif

    return DATALOGGER_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function: