Data Log Public API

Public functions to interact with the data log subsystem. More...

Collaboration diagram for Data Log Public API:

Functions
ERR_te	datalog_init_subsys (void)
	Initializes the data log subsystem.
ERR_te	datalog_deinit_subsys (void)
	Deinitializes the data log subsystem.
ERR_te	datalog_start_subsys (void)
	Starts the data log subsystem.
ERR_te	datalog_stop_subsys (void)
	Stops the data log subsystem.
ERR_te	datalog_init_handle (DATALOG_CFG_ts const *datalog_cfg, DATALOG_HANDLE_ts **datalog_handle_o)
	Initializes and registers a data log handle.
ERR_te	datalog_deinit_handle (DATALOG_HANDLE_ts const *datalog_handle)
	Deinitializes a data log handle.
ERR_te	datalog_run_handle (DATALOG_HANDLE_ts *datalog_handle)
	Writes a GPS data entry to the log file if the logging interval has elapsed.

Detailed Description

Public functions to interact with the data log subsystem.

Function Documentation

datalog_init_subsys()

ERR_te datalog_init_subsys

(

void

)

Initializes the data log subsystem.

Resets the internal state, sets up dependencies (log, systick, NEO-6), and registers the subsystem CLI commands.

Must be called before any other data log API function.

Returns

• ERR_OK on success
• ERR_MODULE_ALREADY_INITIALIZED if the subsystem is already initialized
• Propagated error from cmd_register on failure

Note

Should only be called once during system startup.

See also

datalog_init_subsys

Definition at line 137 of file datalog.c.

                                 {
    ERR_te err;
 
    if(internal_state.initialized) {
        return ERR_MODULE_ALREADY_INITIALIZED;
    }
 
    internal_state = (struct internal_state_s){ 0 };
 
    internal_state.log_level = LOG_LEVEL_INFO;
    internal_state.subsys = MODULES_DATALOG;
    internal_state.initialized = true;
    internal_state.started = false;
 
    init_log();
    init_systick();
    init_neo6();
 
    err = cmd_register(&datalog_cmd_client_info);
    if(err != ERR_OK) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "datalog_init_subsys: cmd_register error"
        );
        return err;
    }
    LOG_INFO(
        internal_state.subsys,
        internal_state.log_level,
        "datalog_init_subsys: subsys initialized"
    );
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

datalog_deinit_subsys()

ERR_te datalog_deinit_subsys

(

void

)

Deinitializes the data log subsystem.

Resets the internal state to zero and deregisters the CLI commands.

Returns

• ERR_OK on success
• ERR_DEINITIALIZATION_FAILURE if the subsystem is not initialized

Note

All handles should be deinitialized before calling this function.

See also

datalog_deinit_subsys

Definition at line 174 of file datalog.c.

                                   {
    if(internal_state.initialized) {
        internal_state = (struct internal_state_s){ 0 };
 
        cmd_deregister(&datalog_cmd_client_info);
    }
    else {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "datalog_deinit_subsys: subsys is not initialized"
        );
 
        return ERR_DEINITIALIZATION_FAILURE;
    }
    LOG_INFO(
        internal_state.subsys,
        internal_state.log_level,
        "datalog_deinit_subsys: subsys deinitialized"
    );
 
    return ERR_OK;
}

Here is the call graph for this function:

datalog_start_subsys()

ERR_te datalog_start_subsys

(

void

)

Starts the data log subsystem.

Enables runtime processing. After calling this function, datalog_run_handle will perform log writes on schedule.

Returns

• ERR_OK on success
• ERR_UNKNOWN if the subsystem is not initialized or already started

Note

Must be called after datalog_init_subsys.

See also

datalog_start_subsys

Definition at line 199 of file datalog.c.

                                  {
    if(internal_state.initialized && !internal_state.started) {
        internal_state.started = true;
 
        LOG_INFO(
            internal_state.subsys,
            internal_state.log_level,
            "datalog_start_subsys: subsys started"
        );
    }
    else {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "datalog_start_subsys: subsys not initialized or already started"
        );
 
        return ERR_UNKNOWN;
    }
 
    return ERR_OK;
}

Here is the caller graph for this function:

datalog_stop_subsys()

ERR_te datalog_stop_subsys

(

void

)

Stops the data log subsystem.

Disables runtime processing. After calling this function, no new log entries will be written.

Returns

• ERR_OK on success
• ERR_UNKNOWN if the subsystem is not initialized or already stopped

Note

Call this before deinitializing the subsystem or handles.

See also

datalog_stop_subsys

Definition at line 223 of file datalog.c.

                                 {
    if(internal_state.initialized && internal_state.started) {
        internal_state.started = false;
 
        LOG_INFO(
            internal_state.subsys,
            internal_state.log_level,
            "datalog_stop_subsys: subsys stopped"
        );
    }
    else {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "datalog_stop_subsys: subsys not initialized or already already stopped"
        );
 
        return ERR_UNKNOWN;
    }
 
    return ERR_OK;
}

datalog_init_handle()

ERR_te datalog_init_handle	(	DATALOG_CFG_ts const *	datalog_cfg,
		DATALOG_HANDLE_ts **	datalog_handle_o )

Initializes and registers a data log handle.

Mounts the FatFs filesystem, creates or truncates the log file (0:datalog.txt), and allocates an internal handle from the pool.

Parameters

[in]	datalog_cfg	Pointer to the log configuration structure.
[out]	datalog_handle_o	Pointer to a handle pointer that will be set to the allocated log instance.

Returns

• ERR_OK on success
• ERR_INITIALIZATION_FAILURE if the subsystem is not initialized or the filesystem mount or file open fails
• ERR_NOT_ENOUGH_SPACE if the maximum number of log handles is reached
• ERR_INVALID_ARGUMENT if datalog_cfg is NULL

See also

datalog_init_handle

Definition at line 247 of file datalog.c.

                                                                                                    {
    uint8_t free_index;
 
    if(!internal_state.initialized) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "datalog_init_handle: subsys not initialized"
        );
 
        return ERR_INITIALIZATION_FAILURE;
    }
 
    if(internal_state.datalog_num == CONFIG_DATALOG_MAX_OBJECTS) {
        LOG_CRITICAL(
            internal_state.subsys,
            internal_state.log_level,
            "datalog_init_handle: subsystem out of memory space"
        );
 
        return ERR_NOT_ENOUGH_SPACE;
    }
 
    if(!datalog_cfg) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "datalog_init_handle: invalid argument"
        );
        return ERR_INVALID_ARGUMENT;
    }
 
    bool found = false;
 
    for(uint32_t i = 0; i < CONFIG_DATALOG_MAX_OBJECTS; i++) {
        if(!internal_state.datalogs[i].in_use) {
            free_index = i;
            found = true;
            break;
        }
    }
 
    if(!found)
        return ERR_NOT_ENOUGH_SPACE;
 
    // Mount filesystem
    internal_state.datalogs[free_index].fr = f_mount(&internal_state.datalogs[free_index].fs, "0:", 1);
    if (internal_state.datalogs[free_index].fr != FR_OK) {
        return ERR_INITIALIZATION_FAILURE;
    }
 
    // Create / open file
    internal_state.datalogs[free_index].fr = f_open(&internal_state.datalogs[free_index].fil, "0:datalog.txt", FA_CREATE_ALWAYS | FA_WRITE);
    if (internal_state.datalogs[free_index].fr != FR_OK) {
        return ERR_INITIALIZATION_FAILURE;
    }
 
    f_close(&internal_state.datalogs[free_index].fil);
 
    str_cpy(
        internal_state.datalogs[free_index].name,
        datalog_cfg->name,
        get_str_len(datalog_cfg->name) + 1
    );
    internal_state.datalogs[free_index].datalog_time = datalog_cfg->datalog_time;
    internal_state.datalogs[free_index].in_use = true;
 
    internal_state.datalog_num++;
 
    *datalog_handle_o = &internal_state.datalogs[free_index];
 
    LOG_INFO(
        internal_state.subsys,
        internal_state.log_level,
        "datalog_init_handle: handle %s initialized",
        internal_state.datalogs[free_index].name
    );
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

datalog_deinit_handle()

ERR_te datalog_deinit_handle

(

DATALOG_HANDLE_ts const *

datalog_handle

)

Deinitializes a data log handle.

Releases the internal resources associated with the given handle and marks the slot as available for reuse.

Parameters

[in]

datalog_handle

Pointer to the handle to deinitialize.

Returns

• ERR_OK on success
• ERR_ILLEGAL_ACTION if the handle is not marked as initialized
• ERR_UNINITIALZIED_OBJECT if the handle is not found in the pool

See also

datalog_deinit_handle

Definition at line 329 of file datalog.c.

                                                                      {
    if(!datalog_handle->initialized) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "datalog_deinit_handle: handle not initialized"
        );
        return ERR_ILLEGAL_ACTION;
    }
 
    if(internal_state.datalog_num == 0) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "datalog_deinit_handle: no such handle to deinitialize"
        );
 
        return ERR_UNINITIALZIED_OBJECT;
    }
 
    for(uint32_t i = 0; i < CONFIG_DATALOG_MAX_OBJECTS; i++) {
        if(&internal_state.datalogs[i] == datalog_handle) {
            uint8_t name_len = get_str_len(internal_state.datalogs[i].name) + 1;
            char name[name_len];
            str_cpy(name, internal_state.datalogs[i].name, name_len);
 
            internal_state.datalogs[i] = (DATALOG_HANDLE_ts){ 0 };
 
            internal_state.datalog_num--;
 
            LOG_INFO(
                internal_state.subsys,
                internal_state.log_level,
                "datalog_deinit_handle: handle %s deinitialized",
                name
            );
 
            break;
        }
 
        if(i == CONFIG_DATALOG_MAX_OBJECTS - 1) {
            LOG_ERROR(
                internal_state.subsys,
                internal_state.log_level,
                "datalog_deinit_handle: no such handle to deinitialize"
            );
 
            return ERR_UNINITIALZIED_OBJECT;
        }
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

datalog_run_handle()

ERR_te datalog_run_handle

(

DATALOG_HANDLE_ts *

datalog_handle

)

Writes a GPS data entry to the log file if the logging interval has elapsed.

Checks whether the configured interval has passed since the last write. If so, opens 0:datalog.txt in append mode and writes the following fields from the NEO-6 GPS module, each on its own line: time, latitude, longitude, orthometric height, movement speed, and movement direction. A blank line is appended after each entry.

Returns immediately without writing if the interval has not yet elapsed.

Parameters

[in,out]

datalog_handle

Pointer to the handle to run.

Returns

• ERR_OK on success or if the logging interval has not elapsed
• ERR_UNKNOWN if the file cannot be opened or a write operation fails

See also

datalog_run_handle

Definition at line 384 of file datalog.c.

                                                             {
    uint32_t time = systick_get_ms();
 
    // Time interval has not been reached yet, return
    if(time - datalog_handle->last_upd_time < datalog_handle->datalog_time * 1000) {
        return ERR_OK;
    }
 
    // Open file
    datalog_handle->fr = f_open(&datalog_handle->fil, "0:datalog.txt", FA_OPEN_APPEND | FA_WRITE);
    if (datalog_handle->fr != FR_OK) {
        return ERR_UNKNOWN;
    }
 
    NEO6_INFO_ts *neo6_info = (void*)0;
    neo6_get_info(&neo6_info);
 
    // Set up time string
    uint32_t time_len = get_str_len(neo6_info->time) + 2;
    char time_str[time_len];
    str_cpy(time_str, neo6_info->time, time_len - 2);
    time_str[time_len - 2] = '\r';
    time_str[time_len - 1] = '\n';
 
    // Write time string to file
    datalog_handle->fr = f_write(&datalog_handle->fil, time_str, time_len, &datalog_handle->bw);
    if (datalog_handle->fr != FR_OK || datalog_handle->bw != time_len) {
        f_close(&datalog_handle->fil);
        return ERR_UNKNOWN;
    }
 
    // Set up latitude string
    uint32_t lat_len = get_str_len(neo6_info->lat) + 2;
    char lat_str[lat_len];
    str_cpy(lat_str, neo6_info->lat, lat_len - 2);
    lat_str[lat_len - 2] = '\r';
    lat_str[lat_len - 1] = '\n';
 
    // Write latitude string to file
    datalog_handle->fr = f_write(&datalog_handle->fil, lat_str, lat_len, &datalog_handle->bw);
    if (datalog_handle->fr != FR_OK || datalog_handle->bw != lat_len) {
        f_close(&datalog_handle->fil);
        return ERR_UNKNOWN;
    }
 
    // Set up longitude string
    uint32_t lon_len = get_str_len(neo6_info->lon) + 2;
    char lon_str[lon_len];
    str_cpy(lon_str, neo6_info->lon, lon_len - 2);
    lon_str[lon_len - 2] = '\r';
    lon_str[lon_len - 1] = '\n';
 
    // Write longitude string to file
    datalog_handle->fr = f_write(&datalog_handle->fil, lon_str, lon_len, &datalog_handle->bw);
    if (datalog_handle->fr != FR_OK || datalog_handle->bw != lon_len) {
        f_close(&datalog_handle->fil);
        return ERR_UNKNOWN;
    }
 
    // Set up orthometric height string
    uint32_t ort_height_len = get_str_len(neo6_info->ort_height) + 2;
    char ort_height_str[ort_height_len];
    str_cpy(ort_height_str, neo6_info->ort_height, ort_height_len - 2);
    ort_height_str[ort_height_len - 2] = '\r';
    ort_height_str[ort_height_len - 1] = '\n';
 
    // Write orthometric height string to file
    datalog_handle->fr = f_write(&datalog_handle->fil, ort_height_str, ort_height_len, &datalog_handle->bw);
    if (datalog_handle->fr != FR_OK || datalog_handle->bw != ort_height_len) {
        f_close(&datalog_handle->fil);
        return ERR_UNKNOWN;
    }
 
    // Set up movement speed string
    uint32_t mov_speed_len = get_str_len(neo6_info->mov_speed) + 2;
    char mov_speed_str[mov_speed_len];
    str_cpy(mov_speed_str, neo6_info->mov_speed, mov_speed_len - 2);
    mov_speed_str[mov_speed_len - 2] = '\r';
    mov_speed_str[mov_speed_len - 1] = '\n';
 
    // Write movement speed string to file
    datalog_handle->fr = f_write(&datalog_handle->fil, mov_speed_str, mov_speed_len, &datalog_handle->bw);
    if (datalog_handle->fr != FR_OK || datalog_handle->bw != mov_speed_len) {
        f_close(&datalog_handle->fil);
        return ERR_UNKNOWN;
    }
 
    // Set up movement direction string
    uint32_t mov_dir_len = get_str_len(neo6_info->mov_dir) + 2;
    char mov_dir_str[mov_dir_len];
    str_cpy(mov_dir_str, neo6_info->mov_dir, mov_dir_len - 2);
    mov_dir_str[mov_dir_len - 2] = '\r';
    mov_dir_str[mov_dir_len - 1] = '\n';
 
    // Write movement direction string to file
    datalog_handle->fr = f_write(&datalog_handle->fil, mov_dir_str, mov_dir_len, &datalog_handle->bw);
    if (datalog_handle->fr != FR_OK || datalog_handle->bw != mov_dir_len) {
        f_close(&datalog_handle->fil);
        return ERR_UNKNOWN;
    }
 
    datalog_handle->fr = f_write(&datalog_handle->fil, "\r\n", 2, &datalog_handle->bw);
 
    f_close(&datalog_handle->fil);
 
    datalog_handle->last_upd_time = systick_get_ms();
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function: