eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 121 Wiki Activity

pdock 60 test task

Browse Source
This commit is contained in:
Jakob Meier
2020-11-23 11:42:22 +01:00
parent 6c23b00c22
commit 9d092edda4
323 changed files with 132 additions and 41250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

189
gomspace/libutil/include/gs/util/log/appender/appender.h
View File

@ -1,189 +0,0 @@
#ifndef GS_UTIL_LOG_APPENDER_APPENDER_H
#define GS_UTIL_LOG_APPENDER_APPENDER_H
/* Copyright (c) 2013-2018 GomSpace A/S. All rights reserved. */
/**
@file
Log Appender interface.
The log appender interface supports logging to different "stores".
Logging is done through groups, which can be registered to different log appenders.
Each log appender has it's own filter (level mask).
Examples of log appenders could be: console, file, vmem, ...
*/
#include <gs/util/log/log.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
Log appender (forward declaration)
All log groups log to one or more appenders. The Log appender is responsible
for putting the actual log data to a store/console or some other log medium.
*/
typedef struct gs_log_appender gs_log_appender_t;
/**
Log appender record iterator callback function
@param[in] ctx context data for iterator.
@param[in] level log level of record being iterated
@param[in] ts timestamp of record being iterated
@param[in] group group string (zero terminated) of record being iterated
@param[in] msg message string (zero terminated) of record being iterated
@return true/false: Return false to discontinue iteration.
*/
typedef bool (*gs_log_record_iterator_t)(void *ctx, gs_log_level_t level, const gs_timestamp_t *ts, const char *group, const char *msg);
/**
Log appender driver interface
*/
typedef struct {
/** appender init function */
gs_error_t (*init)(gs_log_appender_t *appender);
/** appender function */
void (*append)(gs_log_appender_t *appender, gs_log_level_t level, const gs_log_group_t *group, const gs_timestamp_t * ts, const char * format, va_list va);
/** appender function for isr context */
void (*append_isr)(gs_log_appender_t *appender, gs_log_level_t level, const gs_log_group_t *group, const gs_timestamp_t * ts, const char * format, va_list va);
/** appender function for getting appender details string */
void (*info)(gs_log_appender_t *appender, char * info_str, uint8_t str_size);
/** appender function for iterating stored appenders log history */
void (*hist)(gs_log_appender_t *appender, void * ctx, gs_log_record_iterator_t iter);
/** appender function for clearing it's log history */
void (*clear)(gs_log_appender_t *appender);
/** appender function for flushing cached log entries to it's store.
This is only relevant for appenders implementing a log cache. */
void (*flush)(gs_log_appender_t *appender);
} gs_log_appender_driver_t;
/**
Log appender
All log groups log to one or more appenders. The Log appender is responsible
for putting the actual log data to a store/console or some other log medium.
*/
struct gs_log_appender {
/** Name of the appender */
const char * name;
/** appender driver interface */
const gs_log_appender_driver_t * drv;
/** appender driver configuration data */
const void * drv_config;
/** appender driver data - dynamic/internal data */
void * drv_data;
/** appender level mask */
uint8_t mask;
};
/**
Register an appender for the given log group.
All logging, where the mask matches the groups \a level_mask, will be forwarded to this appender.
@param[in] group_name Name of the group.
@param[in] appender_name Name of appender to register for this group.
@return gs_error_t
*/
gs_error_t gs_log_group_register_appender(const char * group_name, const char * appender_name);
/**
Log appender iterator callback function
@param[in] ctx context data for iterator.
@param[in] appender log appender being iterated
@return true/false: Return false to discontinue iteration.
*/
typedef bool (*gs_log_appender_iterator_t)(void *ctx, gs_log_appender_t * appender);
/**
Iterate all or specific log appender(s).
@param[in] name name of log appender, or NULL/\"all\" for all groups.
@param[in] ctx user context data.
@param[in] iter iterator, return \a true to continue, \a false to break iteration.
@return_gs_error_t
*/
gs_error_t gs_log_appender_iterate(const char * name, void * ctx, gs_log_appender_iterator_t iter);
/**
Iterate registered appenders for a specific group.
@param[in] group log group to iterate appenders on.
@param[in] ctx user context data.
@param[in] iter appender iterator, return \a true to continue, \a false to break iteration.
@return gs_error_t
*/
gs_error_t gs_log_group_appender_iterate(gs_log_group_t * group, void * ctx, gs_log_appender_iterator_t iter);
/**
Register log appender.
The log appender will be registered and initialized (if the appender has en init function, see #gs_log_appender_driver_t)
The appender will not be attached to any log groups. For registering an appender to a group, use gs_log_group_register_appender()
@param[in] appender appender - must stay in memory during the life-time of the application
@return_gs_error_t
*/
gs_error_t gs_log_appender_register(gs_log_appender_t *appender);
/**
Add log appender(s).
The log appender will be registered and initialized (if the appender has en init function, see #gs_log_appender_driver_t)
The appender will not be attached to any log groups. For registering an appender to a group, use gs_log_group_register_appender()
@deprecated impossible to determine which appender fails, use gs_log_appender_register()
@param[in] appenders array of appender(s) - must stay in memory during the life-time of the application
@param[in] count array count - number of appenders.
@return_gs_error_t
*/
gs_error_t gs_log_appender_add(gs_log_appender_t *appenders, uint16_t count);
/**
Set log appender level mask.
@param[in] appender_name log appender name
@param[in] mask level mask to set.
@return_gs_error_t
*/
gs_error_t gs_log_appender_set_level_mask(const char * appender_name, uint8_t mask);
/**
Get log appender level mask.
@param[in] appender_name log appender name
@param[out] mask returned current level mask.
@return_gs_error_t
*/
gs_error_t gs_log_appender_get_level_mask(const char * appender_name, uint8_t *mask);
/**
Iterate log history for all or specific log appender.
@param[in] name name of log appender, or NULL/\"all\" for all appenders.
@param[in] ctx user context data for iterator.
@param[in] iter iterator, return \a true to continue, \a false to break iteration.
@return gs_error_t
*/
gs_error_t gs_log_appender_history_iterate(const char * name, void * ctx, gs_log_record_iterator_t iter);
/**
Flush all log appenders data to storage.
This will call the flush API (if implemented) for all log appenders
available on the system. This should be called on regular basis from
a system thread to ensure all cached data is correctly flushed to their
stores.
@return gs_error_t
*/
gs_error_t gs_log_appender_flush_all();
#ifdef __cplusplus
}
#endif
#endif

57
gomspace/libutil/include/gs/util/log/appender/console.h
View File

@ -1,57 +0,0 @@
#ifndef GS_UTIL_LOG_APPENDER_CONSOLE_H
#define GS_UTIL_LOG_APPENDER_CONSOLE_H
/* Copyright (c) 2013-2018 GomSpace A/S. All rights reserved. */
/**
@file
Console log appender - logs to stdout.
*/
#include <gs/util/log/appender/appender.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
Log appender for console
This log appender is the standard appender which is always available
on any system. The appender should be registered to the root group,
in order to get console/stdio logs.
*/
extern gs_log_appender_t gs_log_appender_console;
/**
Log appender for console callback type
This callback function can be used for registering a user defined logger function if
the default can not be used for the given system.
@param[in] appender pointer to the console appender.
@param[in] level log level for log message
@param[in] group log group for log message
@param[in] ts timestamp for log message
@param[in] format format of message in printf style
@param[in] va variable argument list in printf style
@return void
*/
typedef void (*gs_log_appender_console_cb_t)(gs_log_appender_t *appender, gs_log_level_t level, const gs_log_group_t *group, const gs_timestamp_t * ts, const char * format, va_list va);
/**
Set Log appender for console callback
When set, the given callback is called instead of the default console log function.
To revert back to the default console log function, call this function with NULL as parameter.
@param[in] cb callback to use for console logging.
@return gs_error_t
*/
gs_error_t gs_log_appender_console_set_cb(gs_log_appender_console_cb_t cb);
#ifdef __cplusplus
}
#endif
#endif

41
gomspace/libutil/include/gs/util/log/appender/simple_file.h
View File

@ -1,41 +0,0 @@
#ifndef GS_UTIL_LOG_APPENDER_SIMPLE_FILE_H
#define GS_UTIL_LOG_APPENDER_SIMPLE_FILE_H
/* Copyright (c) 2013-2018 GomSpace A/S. All rights reserved. */
/**
@file
Simple log-file appender.
*/
#include <gs/util/log/appender/appender.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
Simple File Log Appender driver configuration
*/
typedef struct gs_log_appender_simple_file_config {
/**
Name of file to create/write logs to
*/
const char *filename;
/**
Truncate the file, when opening the log file.
*/
bool truncate;
/**
Uee local time stamps when logging to log file, otherwise UTC.
*/
bool use_local_time;
} gs_log_appender_simple_file_config_t;
/**
Log appender for file.
*/
extern const gs_log_appender_driver_t gs_log_appender_simple_file_driver;
#ifdef __cplusplus
}
#endif
#endif

853
gomspace/libutil/include/gs/util/log/log.h
View File

@ -1,853 +0,0 @@
#ifndef GS_UTIL_LOG_LOG_H
#define GS_UTIL_LOG_LOG_H
/* Copyright (c) 2013-2018 GomSpace A/S. All rights reserved. */
/**
@file
Log interface.
Logging is done through groups (domains), where the level mask can be changed runtime.
*/
#include <gs/util/error.h>
#include <gs/util/timestamp.h>
#include <gs/util/pgm.h>
#include <inttypes.h>
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
Name of the root log group
*/
#define GS_LOG_GROUP_ROOT "root"
/**
Log levels.
The levels can easily be mapped to standard syslog severity levels (https://en.wikipedia.org/wiki/Syslog).
*/
typedef enum {
/**
Trace (more detailed than \a debug).
syslog: maps to \a debug (or \a trace if supported).
*/
GS_LOG_TRACE = 0,
/**
Debug.
syslog: maps to \a debug.
*/
GS_LOG_DEBUG = 1,
/**
Informational.
syslog: maps to \a informational.
*/
GS_LOG_INFO = 2,
/**
Normal but significant conditions.
syslog: maps to \a notice.
*/
GS_LOG_NOTICE = 3,
/**
Warning.
syslog: maps to \a warning.
*/
GS_LOG_WARNING = 4,
/**
Error.
syslog: maps to \a error.
*/
GS_LOG_ERROR = 5,
/**
Trace (more detailed than \a debug).
@deprecated use #GS_LOG_TRACE
*/
LOG_TRACE = GS_LOG_TRACE,
/**
Debug.
@deprecated use #GS_LOG_DEBUG
*/
LOG_DEBUG = GS_LOG_DEBUG,
/**
Informational.
@deprecated use #GS_LOG_INFO
*/
LOG_INFO = GS_LOG_INFO,
/**
Normal but significant conditions.
@deprecated use #GS_LOG_NOTICE
*/
LOG_NOTICE = GS_LOG_NOTICE,
/**
Warning.
@deprecated use #GS_LOG_WARNING
*/
LOG_WARNING = GS_LOG_WARNING,
/**
Error.
@deprecated use #GS_LOG_ERROR
*/
LOG_ERROR = GS_LOG_ERROR,
} gs_log_level_t;
/**
Log categories.
The category is a way of grouping information about which sub-systems have logged. It is primarily used in the \a
telemetry table, to indicate what sub-systems have logged an \a error or \a warning - indicating a possible problem.
Up to 32 categories are supported (stored in a uint32).
Categories should be unique within a single node. However, nothing happens if categories clashes - it will only be more difficult to determine what part of the system logged.
Standard categories are defined from #GS_LOG_CAT_1 and up. Products or mission specific software should start from #GS_LOG_CAT_32 and down.
*/
typedef enum {
//! Standard, used for #GS_LOG_CAT_DEFAULT
GS_LOG_CAT_1 = 1 << 0,
//! Standard, used for #GS_LOG_CAT_DRIVER
GS_LOG_CAT_2 = 1 << 1,
//! Standard, used for #GS_LOG_CAT_CSP
GS_LOG_CAT_3 = 1 << 2,
//! Standard, used for #GS_LOG_CAT_PARAM
GS_LOG_CAT_4 = 1 << 3,
//! Standard, used for #GS_LOG_CAT_FILE_SYSTEM
GS_LOG_CAT_5 = 1 << 4,
//! Standard, used for #GS_LOG_CAT_COMMAND
GS_LOG_CAT_6 = 1 << 5,
//! Standard, used for #GS_LOG_CAT_HK
GS_LOG_CAT_7 = 1 << 6,
//! Standard, used for #GS_LOG_CAT_FP
GS_LOG_CAT_8 = 1 << 7,
//! Standard, used for #GS_LOG_CAT_ADCS
GS_LOG_CAT_9 = 1 << 8,
GS_LOG_CAT_10 = 1 << 9,
GS_LOG_CAT_11 = 1 << 10,
GS_LOG_CAT_12 = 1 << 11,
GS_LOG_CAT_13 = 1 << 12,
GS_LOG_CAT_14 = 1 << 13,
GS_LOG_CAT_15 = 1 << 14,
GS_LOG_CAT_16 = 1 << 15,
#if (__AVR__ == 0)
GS_LOG_CAT_17 = 1 << 16,
GS_LOG_CAT_18 = 1 << 17,
GS_LOG_CAT_19 = 1 << 18,
GS_LOG_CAT_20 = 1 << 19,
GS_LOG_CAT_21 = 1 << 20,
GS_LOG_CAT_22 = 1 << 21,
GS_LOG_CAT_23 = 1 << 22,
GS_LOG_CAT_24 = 1 << 23,
GS_LOG_CAT_25 = 1 << 24,
GS_LOG_CAT_26 = 1 << 25,
GS_LOG_CAT_27 = 1 << 26,
GS_LOG_CAT_28 = 1 << 27,
GS_LOG_CAT_29 = 1 << 28,
GS_LOG_CAT_30 = 1 << 29,
GS_LOG_CAT_31 = 1 << 30,
//! Product or mission specific - start here and down
GS_LOG_CAT_32 = 1 << 31,
#endif
} gs_log_category_t;
/**
@defgroup reserved_log_categories Reserved/assigned log categories.
These categories are assigned/reserved for certain sub-systems.
@{
*/
/**
Default, used if nothing else fits.
*/
#define GS_LOG_CAT_DEFAULT GS_LOG_CAT_1
/**
Driver layer.
*/
#define GS_LOG_CAT_DRIVER GS_LOG_CAT_2
/**
CSP.
*/
#define GS_LOG_CAT_CSP GS_LOG_CAT_3
/**
Parameter system.
*/
#define GS_LOG_CAT_PARAM GS_LOG_CAT_4
/**
File system.
*/
#define GS_LOG_CAT_FILE_SYSTEM GS_LOG_CAT_5
/**
Command framework and execution.
*/
#define GS_LOG_CAT_COMMAND GS_LOG_CAT_6
/**
Housekeeping System.
*/
#define GS_LOG_CAT_HK GS_LOG_CAT_7
/**
Flight Planner.
*/
#define GS_LOG_CAT_FP GS_LOG_CAT_8
/**
ADCS
*/
#define GS_LOG_CAT_ADCS GS_LOG_CAT_9
/** @} */
struct gs_log_list; /* forward declared private log list struct */
/**
Log list type (private)
Private gs_log_list type.
*/
typedef struct gs_log_list gs_log_list_t;
/**
Log group.
All logs are logged to a \a group. The group contains the current log level mask,
which controls whether the log is carried through or not.
*/
typedef struct {
/**
Name of log group.
*/
const char * name;
/**
Category, see #gs_log_category_t.
*/
uint32_t category;
/**
Current level mask, see #gs_log_level_t.
*/
uint8_t mask;
/**
Is group additive, if \a true (default) logging will be done on both root appenders and this groups appenders - if \a false, logging will only be done to this groups appenders.
*/
bool additivity;
/**
Private list of appenders.
*/
gs_log_list_t * appenders;
#if (__AVR__)
uint16_t dummy_align;
#endif
} gs_log_group_t;
/**
Log masks (levels converted to mask).
@{
*/
/**
Trace level enabled.
*/
#define GS_LOG_TRACE_MASK (1 << GS_LOG_TRACE)
/**
Debug level enabled.
*/
#define GS_LOG_DEBUG_MASK (1 << GS_LOG_DEBUG)
/**
Info level enabled.
*/
#define GS_LOG_INFO_MASK (1 << GS_LOG_INFO)
/**
Notice level enabled.
*/
#define GS_LOG_NOTICE_MASK (1 << GS_LOG_NOTICE)
/**
Warning level enabled.
*/
#define GS_LOG_WARNING_MASK (1 << GS_LOG_WARNING)
/**
Error level enabled.
*/
#define GS_LOG_ERROR_MASK (1 << GS_LOG_ERROR)
/**
All levels enabled.
*/
#define GS_LOG_ALL_MASK (GS_LOG_TRACE_MASK | GS_LOG_DEBUG_MASK | GS_LOG_INFO_MASK | GS_LOG_NOTICE_MASK | GS_LOG_WARNING_MASK | GS_LOG_ERROR_MASK)
/**
Default levels enabled - #GS_LOG_ERROR, #GS_LOG_WARNING and #GS_LOG_NOTICE.
*/
#define GS_LOG_DEFAULT_MASK (GS_LOG_ERROR_MASK | GS_LOG_WARNING_MASK | GS_LOG_NOTICE_MASK)
/**
Trace level enabled.
@deprecated use #GS_LOG_TRACE_MASK
*/
#define LOG_TRACE_MASK GS_LOG_TRACE_MASK
/**
Debug level enabled.
@deprecated use #GS_LOG_DEBUG_MASK
*/
#define LOG_DEBUG_MASK GS_LOG_DEBUG_MASK
/**
Info level enabled.
@deprecated use #GS_LOG_INFO_MASK
*/
#define LOG_INFO_MASK GS_LOG_INFO_MASK
/**
Notice level enabled.
@deprecated use #GS_LOG_NOTICE_MASK
*/
#define LOG_NOTICE_MASK GS_LOG_NOTICE_MASK
/**
Warning level enabled.
@deprecated use #GS_LOG_WARNING_MASK
*/
#define LOG_WARNING_MASK GS_LOG_WARNING_MASK
/**
Error level enabled.
@deprecated use #GS_LOG_ERROR_MASK
*/
#define LOG_ERROR_MASK GS_LOG_ERROR_MASK
/**
All levels enabled.
@deprecated use #GS_LOG_ALL_MASK
*/
#define LOG_ALL_MASK GS_LOG_ALL_MASK
/**
Default levels enabled - #GS_LOG_ERROR, #GS_LOG_WARNING and #GS_LOG_NOTICE.
@deprecated use #GS_LOG_DEFAULT_MASK
*/
#define LOG_DEFAULT_MASK GS_LOG_DEFAULT_MASK
/**@}*/
/**
Define/Create a log group.
@note name clash: This defines a variable, which potentially is \a global, meaning possibility of name clashes. Therefore log group should always
be prefixed with something that makes it fairly unique, i.e. component name. Example: gs_a3200dock_log - log group used by liba3200dock library.
@param[in] group name of variables created. See note above about name clash.
@param[in] name_in display name
@param[in] cat_in log group category
@param[in] level_mask log level mask.
*/
#define GS_LOG_GROUP(group, name_in, cat_in, level_mask) \
gs_log_group_t group##_s = {.name = name_in, .category = cat_in, \
.mask = level_mask, .additivity = true, \
.appenders = NULL}; \
gs_log_group_t * group = &group##_s
/**
Define log group with initial mask for \a print and \a store.
@note name clash: This defines a variable, which potentially is \a global, meaning possibility of name clashes. Therefore log group should always
be prefixed with something that makes it fairly unique, i.e. component name. Example: gs_a3200dock_log - log group used by liba3200dock library.
@deprecated This MACRO is no longer supported, use #GS_LOG_GROUP(...) instead.
@param[in] group name of variables created. See note above about name clash.
@param[in] name_in display name
@param[in] print_mask enable mask for \a print.
@param[in] store_mask enable mask for \a store.
*/
#define LOG_GROUP_MASKED(group, name_in, print_mask, store_mask) GS_LOG_GROUP(group, name_in, GS_LOG_CAT_DEFAULT, (print_mask | store_mask))
/**
Declare log group as external (defined else where).
@param[in] group the log group variable defined elsewhere.
*/
#define GS_LOG_GROUP_EXTERN(group) extern gs_log_group_t * group
/**
Define log group - levels are #GS_LOG_DEFAULT_MASK
@deprecated This MACRO is no longer supported, use #GS_LOG_GROUP(..) instead.
*/
#define LOG_GROUP(group, name_in) GS_LOG_GROUP(group, name_in, GS_LOG_CAT_DEFAULT, LOG_DEFAULT_MASK)
/**
Define verbose log group - all levels are enabled (#GS_LOG_ALL_MASK)
@deprecated This MACRO is no longer supported, use #GS_LOG_GROUP(..) instead.
*/
#define LOG_GROUP_VERBOSE(group, name_in) GS_LOG_GROUP(group, name_in, GS_LOG_CAT_DEFAULT, LOG_ALL_MASK)
/**
Define silent log group - all levels are disabled.
@deprecated This MACRO is no longer supported, use #GS_LOG_GROUP(..) instead.
*/
#define LOG_GROUP_SILENT(group, name_in) GS_LOG_GROUP(group, name_in, GS_LOG_CAT_DEFAULT, 0)
/**
Declare log group as external (defined else where).
@deprecated use #GS_LOG_GROUP_EXTERN(...) instead.
*/
#define LOG_GROUP_EXTERN(group) GS_LOG_GROUP_EXTERN(group)
/**
Default log group.
This can be overridden by a define
*/
extern gs_log_group_t * LOG_DEFAULT;
/**
Initializes the log system.
@param[in] with_console_appender Enable/Disable console log appender
@return_gs_error_t
*/
gs_error_t gs_log_init(bool with_console_appender);
/**
Set log group level mask.
@param[in] group_name log group name
@param[in] mask level mask to set.
@return_gs_error_t
*/
gs_error_t gs_log_group_set_level_mask(const char * group_name, uint8_t mask);
/**
Get log group level mask.
@param[in] group_name log group name
@param[out] mask returned current level mask.
@return_gs_error_t
*/
gs_error_t gs_log_group_get_level_mask(const char * group_name, uint8_t *mask);
/**
Log group iterator callback function
@param[in] ctx context data for iterator.
@param[in] group log group being iterated.
@return true/false: Return false to discontinue iteration.
*/
typedef bool (*gs_log_group_iterator_t)(void *ctx, gs_log_group_t * group);
/**
Iterate all or specific log group(s).
@param[in] group_name name of log group, or NULL/\"all\" for all groups.
@param[in] ctx user context data.
@param[in] iter iterator, return \a true to continue, \a false to break iteration.
@return_gs_error_t
*/
gs_error_t gs_log_group_iterate(const char * group_name, void * ctx, gs_log_group_iterator_t iter);
/**
Register a log group in the log system.
The log group will be added to a system wide list of log groups, enabling list and set of level.
@note The group must remain valid during the life-time of the application.
@param[in] group The log group to be added to the system.
@return_gs_error_t
*/
gs_error_t gs_log_group_register(gs_log_group_t *group);
/**
Register a log group in the log system.
@note The group must stay in memory during the life-time of the application
@see gs_log_group_register()
@param[in] group The log group to be added to the system.
@return_gs_error_t
*/
static inline gs_error_t gs_log_group_add(gs_log_group_t *group)
{
return gs_log_group_register(group);
}
/**
Checks if a level is enabled on a log group
@param[in] group The log group to check.
@param[in] level The log level to check if it's set on the group.
@return bool (true if enabled / false if not enabled)
*/
bool gs_log_group_is_level_enabled(gs_log_group_t *group, gs_log_level_t level);
/**
Convert string to log level.
@param[in] str log level.
@param[out] return_level converted log level.
@return_gs_error_t
*/
gs_error_t gs_log_string_to_level(const char * str, gs_log_level_t * return_level);
/**
Convert level to single character.
@param[in] level log level
@return single character representing the \a level.
*/
char gs_log_level_to_char(gs_log_level_t level);
/**
Register Log commands.
@return_gs_error_t
*/
gs_error_t gs_log_register_commands(void);
/**
Generic log.
@note This function should not be called directly, use log macros.
@param level log level
@param group log group. If NULL, the \a default log group will be used.
@param format Format string (printf style).
*/
void gs_log(gs_log_level_t level, gs_log_group_t * group, const char * format, ...) __attribute__ ((format (__printf__, 3, 4)));
/**
Generic log from ISR.
@note This function should not be called directly, use log macros.
@param level log level
@param group log group. If NULL, the \a default log group will be used.
@param format Format string (printf style).
*/
void gs_log_isr(gs_log_level_t level, gs_log_group_t * group, const char * format, ...) __attribute__ ((format (__printf__, 3, 4)));
/**
Generic log (va_list).
@note This function should not be called directly, use log macros.
@param level log level
@param group log group. If NULL, the \a default log group will be used.
@param format Format string (printf style).
@param args arguments for \a format.
*/
void gs_log_va(gs_log_level_t level, gs_log_group_t * group, const char * format, va_list args);
/**
Enable/disable color in \a print logs.
Default is \a enabled/true.
@param[in] color \a true to enable color, \a false disable color.
*/
void gs_log_set_print_color(bool color);
/**
Level to color (begin).
@param[in] level log level.
@return color string.
*/
const char * gs_log_level_to_color_begin(gs_log_level_t level);
/**
Level to color (end).
@return color string.
*/
const char * gs_log_level_to_color_end(void);
/**
Take a level as input an create a level mask enabling all
levels with priority >= level.
If level is e.g. LOG_INFO, the mask will enable Error, Warn & Info.
* @param level the log level.
* @return level mask
*/
uint8_t gs_log_level_to_mask(gs_log_level_t level);
/**
Convert string to log mask.
Format: [+-]level[,[+-]level]
+ add level, - remove level.
@param[in] str log mask
@param[in] current_mask current mask, used when input format contains + or -.
@param[out] return_mask converted log mask.
@return_gs_error_t
*/
gs_error_t gs_log_string_to_mask(const char *str, uint8_t current_mask, uint8_t * return_mask);
#if !(__DOXYGEN__)
/**
Internal macro for checking if log is enabled, before making log.
*/
#define __gs_log(level, group, format, ...) \
if (group->mask & (1 << level)) { \
gs_log(level, group, GS_PGM_STR(format), ##__VA_ARGS__); \
}
/**
Internal macro for checking if log is enabled for isr, before making log.
*/
#define __gs_log_isr(level, group, format, ...) \
if (group->mask & (1 << level)) { \
gs_log_isr(level, group, GS_PGM_STR(format), ##__VA_ARGS__); \
}
/**
Internal macro used for performing a log only once.
@note This creates a \a static \a variable.
*/
#define __gs_log_once(level, group, format, ...) \
({ \
static bool print_once; \
if (!print_once) { \
print_once = true; \
__gs_log(level, group, format, ##__VA_ARGS__); \
} \
})
#endif // __DOXYGEN__
/**
Default compile-time enabling/disabling of all levels
Unless levels are individually defined, this will be the default value.
*/
#if !defined(GS_LOG_DISABLE_ALL)
#define GS_LOG_DISABLE_ALL 0
#endif
/**
Disable \a error level compile-time by defining a value > 0
*/
#if !defined(GS_LOG_DISABLE_ERROR)
#define GS_LOG_DISABLE_ERROR GS_LOG_DISABLE_ALL
#endif
/**
Disable \a warning level compile-time by defining a value > 0
*/
#if !defined(GS_LOG_DISABLE_WARNING)
#define GS_LOG_DISABLE_WARNING GS_LOG_DISABLE_ALL
#endif
/**
Disable \a notice level compile-time by defining a value > 0
*/
#if !defined(GS_LOG_DISABLE_NOTICE)
#define GS_LOG_DISABLE_NOTICE GS_LOG_DISABLE_ALL
#endif
/**
Disable \a info level compile-time by defining a value > 0
*/
#if !defined(GS_LOG_DISABLE_INFO)
#define GS_LOG_DISABLE_INFO GS_LOG_DISABLE_ALL
#endif
/**
Disable \a debug level compile-time by defining a value > 0
*/
#if !defined(GS_LOG_DISABLE_DEBUG)
#define GS_LOG_DISABLE_DEBUG GS_LOG_DISABLE_ALL
#endif
/**
Disable \a trace level compile-time by defining a value > 0
*/
#if !defined(GS_LOG_DISABLE_TRACE)
#define GS_LOG_DISABLE_TRACE GS_LOG_DISABLE_ALL
#endif
/**
Log \a error to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_error(format, ...) { if (!GS_LOG_DISABLE_ERROR) __gs_log(LOG_ERROR, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a error from ISR to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_error_isr(format, ...) { if (!GS_LOG_DISABLE_ERROR) __gs_log_isr(LOG_ERROR, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a error to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_error_group(group, format, ...) { if (!GS_LOG_DISABLE_ERROR) __gs_log(LOG_ERROR, (group), format, ##__VA_ARGS__); }
/**
Log \a error only once to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_error_once(format, ...) { if (!GS_LOG_DISABLE_ERROR) __gs_log_once(LOG_ERROR, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a error only once to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_error_once_group(group, format, ...) { if (!GS_LOG_DISABLE_ERROR) __gs_log_once(LOG_ERROR, (group), format, ##__VA_ARGS__); }
/**
Log \a warning to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_warning(format, ...) { if (!GS_LOG_DISABLE_WARNING) __gs_log(LOG_WARNING, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a warning from ISR to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_warning_isr(format, ...) { if (!GS_LOG_DISABLE_WARNING) __gs_log_isr(LOG_WARNING, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a warning to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_warning_group(group, format, ...) { if (!GS_LOG_DISABLE_WARNING) __gs_log(LOG_WARNING, (group), format, ##__VA_ARGS__); }
/**
Log \a warning only once to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_warning_once(format, ...) { if (!GS_LOG_DISABLE_WARNING) __gs_log_once(LOG_WARNING, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a warning only once to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_warning_once_group(group, format, ...) { if (!GS_LOG_DISABLE_WARNING) __gs_log_once(LOG_WARNING, (group), format, ##__VA_ARGS__); }
/**
Log \a notice to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_notice(format, ...) { if (!GS_LOG_DISABLE_NOTICE) __gs_log(LOG_NOTICE, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a notice from ISR to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_notice_isr(format, ...) { if (!GS_LOG_DISABLE_NOTICE) __gs_log_isr(LOG_NOTICE, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a notice to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_notice_group(group, format, ...) { if (!GS_LOG_DISABLE_NOTICE) __gs_log(LOG_NOTICE, (group), format, ##__VA_ARGS__); }
/**
Log \a notice only once to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_notice_once(format, ...) { if (!GS_LOG_DISABLE_NOTICE) __gs_log_once(LOG_NOTICE, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a notice only once to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_notice_once_group(group, format, ...) { if (!GS_LOG_DISABLE_NOTICE) __gs_log_once(LOG_NOTICE, (group), format, ##__VA_ARGS__); }
/**
Log \a info to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_info(format, ...) { if (!GS_LOG_DISABLE_INFO) __gs_log(LOG_INFO, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a info from ISR to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_info_isr(format, ...) { if (!GS_LOG_DISABLE_INFO) __gs_log_isr(LOG_INFO, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a info to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_info_group(group, format, ...) { if (!GS_LOG_DISABLE_INFO) __gs_log(LOG_INFO, (group), format, ##__VA_ARGS__); }
/**
Log \a info only once to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_info_once(format, ...) { if (!GS_LOG_DISABLE_INFO) __gs_log_once(LOG_INFO, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a info only once to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_info_once_group(group, format, ...) { if (!GS_LOG_DISABLE_INFO) __gs_log_once(LOG_INFO, (group), format, ##__VA_ARGS__); }
/**
Log \a debug to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_debug(format, ...) { if (!GS_LOG_DISABLE_DEBUG) __gs_log(LOG_DEBUG, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a debug from ISR to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_debug_isr(format, ...) { if (!GS_LOG_DISABLE_DEBUG) __gs_log_isr(LOG_DEBUG, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a debug to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_debug_group(group, format, ...) { if (!GS_LOG_DISABLE_DEBUG) __gs_log(LOG_DEBUG, (group), format, ##__VA_ARGS__); }
/**
Log \a debug only once to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_debug_once(format, ...) { if (!GS_LOG_DISABLE_DEBUG) __gs_log_once(LOG_DEBUG, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a debug only once to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_debug_once_group(group, format, ...) { if (!GS_LOG_DISABLE_DEBUG) __gs_log_once(LOG_DEBUG, (group), format, ##__VA_ARGS__); }
/**
Log \a trace to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_trace(format, ...) { if (!GS_LOG_DISABLE_TRACE) __gs_log(LOG_TRACE, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a trace from ISR to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_trace_isr(format, ...) { if (!GS_LOG_DISABLE_TRACE) __gs_log_isr(LOG_TRACE, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a trace to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_trace_group(group, format, ...) { if (!GS_LOG_DISABLE_TRACE) __gs_log(LOG_TRACE, (group), format, ##__VA_ARGS__); }
/**
Log \a trace only once to default group (LOG_DEFAULT).
@param[in] format Format string (printf style).
*/
#define log_trace_once(format, ...) { if (!GS_LOG_DISABLE_TRACE) __gs_log_once(LOG_TRACE, LOG_DEFAULT, format, ##__VA_ARGS__); }
/**
Log \a trace only once to group.
@param[in] group log group (gs_log_group_t *).
@param[in] format Format string (printf style).
*/
#define log_trace_once_group(group, format, ...) { if (!GS_LOG_DISABLE_TRACE) __gs_log_once(LOG_TRACE, (group), format, ##__VA_ARGS__); }
#ifdef __cplusplus
}
#endif
#endif