demo APIs

demo API More...

Data Structures
struct	algorithm_demo_common_config
union	algorithm_demo_common_data

Macros
#define	ALGORITHM_DEMO_EVENT_DEFINE(name, loggers_, tdfs, event_chance_percent)
	Statically define an instance of the demo event algorithm.
#define	ALGORITHM_DEMO_STATE_DEFINE(name, loggers_, tdfs)
	Statically define an instance of the demo state algorithm.
#define	ALGORITHM_DEMO_METRIC_DEFINE(name, loggers_, tdfs, metric_compute_len)
	Statically define an instance of the demo compute algorithm.

Enumerations
enum	{ ALGORITHM_DEMO_EVENT_LOG = BIT(0) , ALGORITHM_DEMO_STATE_LOG = BIT(0) , ALGORITHM_DEMO_METRIC_LOG = BIT(0) }

Functions
void	algorithm_demo_event_fn (const struct zbus_channel *chan, const void *config, void *data)
	Algorithm implementation, see algorithm_run_fn.
void	algorithm_demo_state_fn (const struct zbus_channel *chan, const void *config, void *data)
	Algorithm implementation, see algorithm_run_fn.
void	algorithm_demo_metric_fn (const struct zbus_channel *chan, const void *config, void *data)
	Algorithm implementation, see algorithm_run_fn.

Detailed Description

demo API

Macro Definition Documentation

ALGORITHM_DEMO_EVENT_DEFINE

#define ALGORITHM_DEMO_EVENT_DEFINE	(		name,
			loggers_,
			tdfs,
			event_chance_percent )

#include <infuse/algorithm_runner/algorithms/demo.h>

Value:

        static const struct algorithm_demo_common_config name##_config = {                         \
                .common =                                                                          \
                        {                                                                          \
                                .algorithm_id = 0xFFFFFFF0,                                        \
                                .zbus_channel = INFUSE_ZBUS_CHAN_IMU,                              \
                                .state_size = sizeof(union algorithm_demo_common_data),            \
                                .logging =                                                         \
                                        {                                                          \
                                                .loggers = loggers_,                               \
                                                .tdf_mask = tdfs,                                  \
                                        },                                                         \
                        },                                                                         \
                .event_gen_chance = event_chance_percent,                                          \
        };                                                                                         \
        static union algorithm_demo_common_data name##_data;                                       \
        static struct algorithm_runner_algorithm name = {                                          \
                .impl = algorithm_demo_event_fn,                                                   \
                .config = &name##_config.common,                                                   \
                .runtime_state = &name##_data,                                                     \
        }

Statically define an instance of the demo event algorithm.

This algorithm randomly generates events, with a percentage chance equal to the argument on each IMU sample buffer that arrives.

Parameters

name	Variable name base
loggers_	TDF loggers to log outputs to
tdfs	TDFs to log
event_chance_percent	Chance to emit an event on each buffer

ALGORITHM_DEMO_METRIC_DEFINE

#define ALGORITHM_DEMO_METRIC_DEFINE	(		name,
			loggers_,
			tdfs,
			metric_compute_len )

#include <infuse/algorithm_runner/algorithms/demo.h>

Value:

        static const struct algorithm_demo_common_config name##_config = {                         \
                .common =                                                                          \
                        {                                                                          \
                                .algorithm_id = 0xFFFFFFF2,                                        \
                                .zbus_channel = INFUSE_ZBUS_CHAN_IMU,                              \
                                .state_size = sizeof(union algorithm_demo_common_data),            \
                                .logging =                                                         \
                                        {                                                          \
                                                .loggers = loggers_,                               \
                                                .tdf_mask = tdfs,                                  \
                                        },                                                         \
                        },                                                                         \
                .compute_metric_len = metric_compute_len,                                          \
        };                                                                                         \
        static union algorithm_demo_common_data name##_data;                                       \
        static struct algorithm_runner_algorithm name = {                                          \
                .impl = algorithm_demo_metric_fn,                                                  \
                .config = &name##_config.common,                                                   \
                .runtime_state = &name##_data,                                                     \
        }

Statically define an instance of the demo compute algorithm.

This algorithm generates a compute metric, with one metric computed every N samples

Parameters

name	Variable name base
loggers_	TDF loggers to log outputs to
tdfs	TDFs to log
metric_compute_len	Number of samples to compute metric over

ALGORITHM_DEMO_STATE_DEFINE

#define ALGORITHM_DEMO_STATE_DEFINE	(		name,
			loggers_,
			tdfs )

#include <infuse/algorithm_runner/algorithms/demo.h>

Value:

        static const struct algorithm_demo_common_config name##_config = {                         \
                .common =                                                                          \
                        {                                                                          \
                                .algorithm_id = 0xFFFFFFF1,                                        \
                                .zbus_channel = INFUSE_ZBUS_CHAN_IMU,                              \
                                .state_size = sizeof(union algorithm_demo_common_data),            \
                                .logging =                                                         \
                                        {                                                          \
                                                .loggers = loggers_,                               \
                                                .tdf_mask = tdfs,                                  \
                                        },                                                         \
                        },                                                                         \
        };                                                                                         \
        static union algorithm_demo_common_data name##_data;                                       \
        static struct algorithm_runner_algorithm name = {                                          \
                .impl = algorithm_demo_state_fn,                                                   \
                .config = &name##_config.common,                                                   \
                .runtime_state = &name##_data,                                                     \
        }

Statically define an instance of the demo state algorithm.

This algorithm randomly transitions between states on IMU buffers

Parameters

name	Variable name base
loggers_	TDF loggers to log outputs to
tdfs	TDFs to log

Enumeration Type Documentation

anonymous enum

anonymous enum

#include <infuse/algorithm_runner/algorithms/demo.h>

Enumerator
ALGORITHM_DEMO_EVENT_LOG
ALGORITHM_DEMO_STATE_LOG
ALGORITHM_DEMO_METRIC_LOG

Function Documentation

algorithm_demo_event_fn()

void algorithm_demo_event_fn	(	const struct zbus_channel *	chan,
		const void *	config,
		void *	data )

#include <infuse/algorithm_runner/algorithms/demo.h>

Algorithm implementation, see algorithm_run_fn.

algorithm_demo_metric_fn()

void algorithm_demo_metric_fn	(	const struct zbus_channel *	chan,
		const void *	config,
		void *	data )

#include <infuse/algorithm_runner/algorithms/demo.h>

Algorithm implementation, see algorithm_run_fn.

algorithm_demo_state_fn()

void algorithm_demo_state_fn	(	const struct zbus_channel *	chan,
		const void *	config,
		void *	data )

#include <infuse/algorithm_runner/algorithms/demo.h>

Algorithm implementation, see algorithm_run_fn.