Log Public API

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

Collaboration diagram for Log Public API:

Functions
ERR_te	log_init (LOG_HANDLE_ts *log_handle)
	Initializes the log subsystem.
ERR_te	log_deinit (void)
	Deinitializes the log subsystem.
ERR_te	log_print (MODULES_te subsys, LOG_LEVEL_te subsys_log_level, LOG_LEVEL_te log_level, char *msg,...)
	Prints a formatted message to the serial terminal if the severity threshold is met.
ERR_te	log_get_level_name (LOG_LEVEL_te log_level, char *str)
	Converts a LOG_LEVEL_te value to its lowercase string name.
ERR_te	log_level_to_int (char const *str, LOG_LEVEL_te *log_level_o)
	Converts a log level name string to its LOG_LEVEL_te value.
ERR_te	log_set_force_disable (bool bool_status)
	Enables or disables forced suppression of all log output.

Detailed Description

Public functions to interact with the log subsystem.

Function Documentation

log_init()

ERR_te log_init

(

LOG_HANDLE_ts *

log_handle

)

Initializes the log subsystem.

Configures the TX GPIO pin in alternate function mode, initializes the USART peripheral, enables transmission, and initializes the RTC dependency.

Parameters

[in]

log_handle

Pointer to the log configuration structure.

Returns

• ERR_OK on success
• ERR_MODULE_ALREADY_INITIALIZED if the log subsystem is already initialized

Note

Typically called indirectly via init_log rather than directly.

See also

log_init

Definition at line 56 of file log.c.

                                           {
    if(internal_state.initialized) {
        return ERR_MODULE_ALREADY_INITIALIZED;
    }
 
    internal_state.usart_instance = log_handle->usart_instance;
 
    init_rtc();
 
    GPIO_CFG_ts log_tx_pin = { 0 };
    log_tx_pin.port = log_handle->gpio_port;
    log_tx_pin.pin = log_handle->gpio_pin;
    log_tx_pin.mode = GPIO_MODE_ALTERNATE_FUNCTION;
    log_tx_pin.alternate_function = log_handle->gpio_alternate_function;
    gpio_init(&log_tx_pin);
 
    USART_CFG_ts log_usart = { 0 };
    log_usart.instance = log_handle->usart_instance;
    log_usart.baud_rate = log_handle->usart_baud_rate;
    usart_init(&log_usart);
 
    usart_set_transmission(internal_state.usart_instance, ENABLE);
 
    internal_state.initialized = true;
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_deinit()

ERR_te log_deinit

(

void

)

Deinitializes the log subsystem.

Resets the USART peripheral registers to their reset values and clears the internal state.

Returns

• ERR_OK on success
• ERR_UNINITIALZIED_OBJECT if the log subsystem has not been initialized

See also

log_deinit

Definition at line 85 of file log.c.

                    {
    if(internal_state.usart_instance == (void*)0) {
        return ERR_UNINITIALZIED_OBJECT;
    }
 
    usart_deinit(internal_state.usart_instance);
 
    internal_state.usart_instance = 0;
    internal_state.force_disable = 0;
 
    return ERR_OK;
}

Here is the call graph for this function:

log_print()

ERR_te log_print	(	MODULES_te	subsys,
		LOG_LEVEL_te	subsys_log_level,
		LOG_LEVEL_te	log_level,
		char *	msg,
			... )

Prints a formatted message to the serial terminal if the severity threshold is met.

The message is only transmitted if log_level >= subsys_log_level and force-disable is not active. Each message is preceded by a prologue containing the RTC timestamp, severity level, and subsystem name.

Supported format specifiers:

• d — signed 32-bit integer
• s — null-terminated string
• %.Nf — double with N decimal places (N must be a single digit, 1–9)

Parameters

[in]	subsys	The subsystem emitting the message.
[in]	subsys_log_level	The current log level threshold of the subsystem.
[in]	log_level	The severity level of this message.
[in]	msg	Printf-style format string.
[in]	...	Arguments for the format specifiers in msg.

Returns

• ERR_OK always (filtering is silent, not an error)

Note

Prefer the LOG_INFO, LOG_ERROR, etc. macros over calling this function directly.

See also

log_print

Definition at line 99 of file log.c.

                                                                                                           {
    if (log_level >= subsys_log_level && internal_state.force_disable == false) {
        va_list args;
        va_start(args, msg);
 
        log_print_prologue(subsys, log_level);
 
        while (*msg != '\0') {
            if (*msg == '%') {
                msg++;
 
                if (*msg == 'd') {
                    int32_t num = va_arg(args, int);
                    char num_buf[12];
                    int_to_str(num, num_buf);
                    usart_send(internal_state.usart_instance, (uint8_t*)num_buf, get_str_len(num_buf));
                }
                else if (*msg == 's') {
                    char *str = va_arg(args, char*);
                    usart_send(internal_state.usart_instance, (uint8_t*)str, get_str_len(str));
                }
                else if(*msg == '.') {
                    msg++;
 
                    char dec_places_str[2];
                    dec_places_str[0] = *msg;   // There can be no more than 9 decimal places
                    dec_places_str[1] = '\0';
 
                    msg++;
 
                    if(*msg == 'f') {
                        double num = va_arg(args, double);
                        char num_buf[20] = { 0 };
                        double_to_str(num, num_buf, str_to_int(dec_places_str));
                        usart_send(internal_state.usart_instance, (uint8_t*)num_buf, get_str_len(num_buf));
                    }
                }
            }
            else {
                usart_send(internal_state.usart_instance, (uint8_t*)msg, 1);
            }
 
            msg++;
        }
 
        va_end(args);
 
        usart_send(internal_state.usart_instance, (uint8_t*)"\r\n", 2);
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

log_get_level_name()

ERR_te log_get_level_name	(	LOG_LEVEL_te	log_level,
		char *	str )

Converts a LOG_LEVEL_te value to its lowercase string name.

Writes the level name (e.g. "info", "error") into str. The caller must ensure str is large enough to hold the result and a null terminator.

Parameters

[in]	log_level	The log level to convert.
[out]	str	Pointer to the destination buffer.

Returns

• ERR_OK on success
• ERR_UNKNOWN if log_level is not a recognized value

See also

log_get_level_name

Definition at line 153 of file log.c.

                                                             {
    char const *name;
 
    switch(log_level) {
        case LOG_LEVEL_NONE:
            name = "none";
            break;
 
        case LOG_LEVEL_INFO:
            name = "info";
            break;
 
        case LOG_LEVEL_DEBUG:
            name = "debug";
            break;
 
        case LOG_LEVEL_WARNING:
            name = "warning";
            break;
 
        case LOG_LEVEL_ERROR:
            name = "error";
            break;
 
        case LOG_LEVEL_CRITICAL:
            name = "critical";
            break;
 
        default:
            return ERR_UNKNOWN;
            break;
    }
 
    str_cpy(str, name, get_str_len(name) + 1);
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_level_to_int()

ERR_te log_level_to_int	(	char const *	str,
		LOG_LEVEL_te *	log_level )

Converts a log level name string to its LOG_LEVEL_te value.

Accepts the lowercase level names: "none", "info", "debug", "warning", "error", "critical". Unrecognized strings result in LOG_LEVEL_NONE being written to log_level_o.

Parameters

[in]	str	Pointer to the null-terminated level name string.
[out]	log_level_o	Pointer to a variable that will receive the parsed level.

Returns

• ERR_OK always (unrecognized strings silently default to LOG_LEVEL_NONE)

See also

log_level_to_int

Definition at line 192 of file log.c.

                                                                  {
    if(str_cmp(str, "none") == true) {
        *log_level = LOG_LEVEL_NONE;
    }
    else if(str_cmp(str, "info") == true) {
        *log_level = LOG_LEVEL_INFO;
    }
    else if(str_cmp(str, "debug") == true) {
        *log_level = LOG_LEVEL_DEBUG;
    }
    else if(str_cmp(str, "warning") == true) {
        *log_level = LOG_LEVEL_WARNING;
    }
    else if(str_cmp(str, "error") == true) {
        *log_level = LOG_LEVEL_ERROR;
    }
    else if(str_cmp(str, "critical") == true) {
        *log_level = LOG_LEVEL_CRITICAL;
    }
    else {
        *log_level = LOG_LEVEL_NONE;
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_set_force_disable()

ERR_te log_set_force_disable

(

bool

bool_status

)

Enables or disables forced suppression of all log output.

When force-disable is active, log_print produces no output regardless of severity level or subsystem threshold. Used by the console module to suppress log output during interactive command input.

Parameters

[in]

bool_status

true to suppress all output, false to restore normal operation.

Returns

• ERR_OK always

See also

log_set_force_disable

Definition at line 219 of file log.c.

                                               {
    internal_state.force_disable = bool_status;
 
    return ERR_OK;
}

Here is the caller graph for this function: