- Atomic functions catalog >
- cube.misc.cli_logger
cube.misc.cli_logger¶
Inputs¶
Name |
Type |
Title |
Mandatory |
Description |
|---|---|---|---|---|
v1 |
core.type.f64 |
Variable 1 |
False |
None |
v2 |
core.type.f64 |
Variable 2 |
False |
None |
v3 |
core.type.f64 |
Variable 3 |
False |
None |
v4 |
core.type.f64 |
Variable 4 |
False |
None |
v5 |
core.type.f64 |
Variable 5 |
False |
None |
v6 |
core.type.f64 |
Variable 6 |
False |
None |
v7 |
core.type.f64 |
Variable 7 |
False |
None |
v8 |
core.type.f64 |
Variable 8 |
False |
None |
v9 |
core.type.f64 |
Variable 9 |
False |
None |
v10 |
core.type.f64 |
Variable 10 |
False |
None |
v11 |
core.type.f64 |
Variable 11 |
False |
None |
v12 |
core.type.f64 |
Variable 12 |
False |
None |
Outputs¶
Function has no outputs
Parameters¶
Function has no parameters
State variables¶
Function has no state variables
Usage XML code snippet¶
cube_misc_cli_logger snippet for FLOW configuration file¶
<f name="cli_logger" by_spec="cube.misc.cli_logger">
<in alias="v1">some_block_1/output</in> <!-- optional -->
<in alias="v2">some_block_2/output</in> <!-- optional -->
<in alias="v3">some_block_3/output</in> <!-- optional -->
<in alias="v4">some_block_4/output</in> <!-- optional -->
<in alias="v5">some_block_5/output</in> <!-- optional -->
<in alias="v6">some_block_6/output</in> <!-- optional -->
<in alias="v7">some_block_7/output</in> <!-- optional -->
<in alias="v8">some_block_8/output</in> <!-- optional -->
<in alias="v9">some_block_9/output</in> <!-- optional -->
<in alias="v10">some_block_10/output</in> <!-- optional -->
<in alias="v11">some_block_11/output</in> <!-- optional -->
<in alias="v12">some_block_12/output</in> <!-- optional -->
</f>
Function’s artifacts¶
- Declaration for cube_misc_cli_logger
- Implementation for cube_misc_cli_logger
- Header of cube_misc_cli_logger
- Specification of cube_misc_cli_logger
- Interface of cube_misc_cli_logger
declaration.py¶
from fspeclib import *
Function(
name='cube.misc.cli_logger',
title=LocalizedString(
en='Logger of the string to CLI stdout for debugging purposes'
),
inputs=[
Input(
name='v1',
title='Variable 1',
value_type='core.type.f64',
mandatory=False
),
Input(
name='v2',
title='Variable 2',
value_type='core.type.f64',
mandatory=False
),
Input(
name='v3',
title='Variable 3',
value_type='core.type.f64',
mandatory=False
),
Input(
name='v4',
title='Variable 4',
value_type='core.type.f64',
mandatory=False
),
Input(
name='v5',
title='Variable 5',
value_type='core.type.f64',
mandatory=False
),
Input(
name='v6',
title='Variable 6',
value_type='core.type.f64',
mandatory=False
),
Input(
name='v7',
title='Variable 7',
value_type='core.type.f64',
mandatory=False
),
Input(
name='v8',
title='Variable 8',
value_type='core.type.f64',
mandatory=False
),
Input(
name='v9',
title='Variable 9',
value_type='core.type.f64',
mandatory=False
),
Input(
name='v10',
title='Variable 10',
value_type='core.type.f64',
mandatory=False
),
Input(
name='v11',
title='Variable 11',
value_type='core.type.f64',
mandatory=False
),
Input(
name='v12',
title='Variable 12',
value_type='core.type.f64',
mandatory=False
),
],
outputs=[
],
state=[],
parameter_constraints=[]
)
cube_misc_cli_logger_exec.c¶
#include "cube_misc_cli_logger.h"
void cube_misc_cli_logger_exec(const cube_misc_cli_logger_inputs_t *i){
static char str2post[256];
#define VAR_FMT "%+08.3f "
snprintf(str2post, 255,
VAR_FMT " || "
VAR_FMT VAR_FMT VAR_FMT " || " VAR_FMT VAR_FMT VAR_FMT " || " \
VAR_FMT VAR_FMT VAR_FMT " || " VAR_FMT VAR_FMT VAR_FMT "\n\r",
xTaskGetTickCount() / 1000.f,
i->v1, i->v2, i->v3, i->v4, i->v5, i->v6,
i->v7, i->v8, i->v9, i->v10, i->v11, i->v12
);
printf("%s", str2post);
}
cube_misc_cli_logger.h¶
/**
* Automatically-generated file. Do not edit!
*/
#ifndef FSPEC_CUBE_MISC_CLI_LOGGER_H
#define FSPEC_CUBE_MISC_CLI_LOGGER_H
#include <stdint.h>
#include <eswb/types.h>
#include "function.h"
/* Include declaration of dependency types */
#include "core_type_f64.h"
/**
* @brief Optional inputs connectivity flags structure for `cube.misc.cli_logger` function
*/
typedef struct {
uint32_t v1:1;
uint32_t v2:1;
uint32_t v3:1;
uint32_t v4:1;
uint32_t v5:1;
uint32_t v6:1;
uint32_t v7:1;
uint32_t v8:1;
uint32_t v9:1;
uint32_t v10:1;
uint32_t v11:1;
uint32_t v12:1;
} cube_misc_cli_logger_optional_inputs_flags_t;
/**
* @brief Inputs of `cube.misc.cli_logger` function
*/
typedef struct cube_misc_cli_logger_inputs_ {
core_type_f64_t v1; /// Variable 1
core_type_f64_t v2; /// Variable 2
core_type_f64_t v3; /// Variable 3
core_type_f64_t v4; /// Variable 4
core_type_f64_t v5; /// Variable 5
core_type_f64_t v6; /// Variable 6
core_type_f64_t v7; /// Variable 7
core_type_f64_t v8; /// Variable 8
core_type_f64_t v9; /// Variable 9
core_type_f64_t v10; /// Variable 10
core_type_f64_t v11; /// Variable 11
core_type_f64_t v12; /// Variable 12
cube_misc_cli_logger_optional_inputs_flags_t optional_inputs_flags;
} cube_misc_cli_logger_inputs_t;
typedef struct cube_misc_cli_logger_eswb_descriptors_ {
eswb_topic_descr_t in_v1;
eswb_topic_descr_t in_v2;
eswb_topic_descr_t in_v3;
eswb_topic_descr_t in_v4;
eswb_topic_descr_t in_v5;
eswb_topic_descr_t in_v6;
eswb_topic_descr_t in_v7;
eswb_topic_descr_t in_v8;
eswb_topic_descr_t in_v9;
eswb_topic_descr_t in_v10;
eswb_topic_descr_t in_v11;
eswb_topic_descr_t in_v12;
} cube_misc_cli_logger_eswb_descriptors_t;
typedef struct cube_misc_cli_logger_interface_ {
cube_misc_cli_logger_inputs_t i;
cube_misc_cli_logger_eswb_descriptors_t eswb_descriptors;
} cube_misc_cli_logger_interface_t;
void cube_misc_cli_logger_exec(const cube_misc_cli_logger_inputs_t *i);
#endif // FSPEC_CUBE_MISC_CLI_LOGGER_H
cube_misc_cli_logger_spec.c¶
/**
* Automatically-generated file. Do not edit!
*/
#include "cube_misc_cli_logger.h"
#include <eswb/types.h>
static const param_spec_t *params[1] = {
NULL
};
static const input_spec_t i_v1 = {
.name = "v1",
.annotation = "Variable 1",
.flags = 0
};
static const input_spec_t i_v2 = {
.name = "v2",
.annotation = "Variable 2",
.flags = 0
};
static const input_spec_t i_v3 = {
.name = "v3",
.annotation = "Variable 3",
.flags = 0
};
static const input_spec_t i_v4 = {
.name = "v4",
.annotation = "Variable 4",
.flags = 0
};
static const input_spec_t i_v5 = {
.name = "v5",
.annotation = "Variable 5",
.flags = 0
};
static const input_spec_t i_v6 = {
.name = "v6",
.annotation = "Variable 6",
.flags = 0
};
static const input_spec_t i_v7 = {
.name = "v7",
.annotation = "Variable 7",
.flags = 0
};
static const input_spec_t i_v8 = {
.name = "v8",
.annotation = "Variable 8",
.flags = 0
};
static const input_spec_t i_v9 = {
.name = "v9",
.annotation = "Variable 9",
.flags = 0
};
static const input_spec_t i_v10 = {
.name = "v10",
.annotation = "Variable 10",
.flags = 0
};
static const input_spec_t i_v11 = {
.name = "v11",
.annotation = "Variable 11",
.flags = 0
};
static const input_spec_t i_v12 = {
.name = "v12",
.annotation = "Variable 12",
.flags = 0
};
static const input_spec_t *inputs[13] = {
&i_v1,
&i_v2,
&i_v3,
&i_v4,
&i_v5,
&i_v6,
&i_v7,
&i_v8,
&i_v9,
&i_v10,
&i_v11,
&i_v12,
NULL
};
static const output_spec_t *outputs[1] = {
NULL
};
fspec_rv_t cube_misc_cli_logger_call_init_inputs(
void *dh,
const func_conn_spec_t *conn_spec,
eswb_topic_descr_t mounting_td
);
void cube_misc_cli_logger_call_exec(void *dh);
const function_spec_t atomic_cube_misc_cli_logger_spec = {
.name = "cube.misc.cli_logger",
.annotation = "Logger of the string to CLI stdout for debugging purposes",
.inputs = inputs,
.outputs = outputs,
.params = params
};
const function_calls_t atomic_cube_misc_cli_logger_calls = {
.interface_handle_size = sizeof(cube_misc_cli_logger_interface_t),
.init = NULL,
.init_inputs = cube_misc_cli_logger_call_init_inputs,
.init_outputs = NULL,
.pre_exec_init = NULL,
.exec = cube_misc_cli_logger_call_exec,
.set_params = NULL
};
const function_handler_t atomic_cube_misc_cli_logger_handler = {
.spec = &atomic_cube_misc_cli_logger_spec,
.calls = &atomic_cube_misc_cli_logger_calls,
.extension_handler = NULL
};
cube_misc_cli_logger_interface.c¶
/**
* Automatically-generated file. Do not edit!
*/
#include "cube_misc_cli_logger.h"
#include "error.h"
#include <eswb/api.h>
#include <eswb/topic_proclaiming_tree.h>
#include <eswb/errors.h>
int cube_misc_cli_logger_interface_inputs_init(
cube_misc_cli_logger_interface_t *interface,
const func_conn_spec_t *conn_spec,
eswb_topic_descr_t mounting_td
)
{
eswb_rv_t rv;
int errcnt_no_topic = 0;
int errcnt_no_input = 0;
const char *topic_path_in_v1 = fspec_find_path2connect(conn_spec,"v1");
const char *topic_path_in_v2 = fspec_find_path2connect(conn_spec,"v2");
const char *topic_path_in_v3 = fspec_find_path2connect(conn_spec,"v3");
const char *topic_path_in_v4 = fspec_find_path2connect(conn_spec,"v4");
const char *topic_path_in_v5 = fspec_find_path2connect(conn_spec,"v5");
const char *topic_path_in_v6 = fspec_find_path2connect(conn_spec,"v6");
const char *topic_path_in_v7 = fspec_find_path2connect(conn_spec,"v7");
const char *topic_path_in_v8 = fspec_find_path2connect(conn_spec,"v8");
const char *topic_path_in_v9 = fspec_find_path2connect(conn_spec,"v9");
const char *topic_path_in_v10 = fspec_find_path2connect(conn_spec,"v10");
const char *topic_path_in_v11 = fspec_find_path2connect(conn_spec,"v11");
const char *topic_path_in_v12 = fspec_find_path2connect(conn_spec,"v12");
// Connecting optional input "v1"
if (topic_path_in_v1 != NULL) {
interface->i.optional_inputs_flags.v1 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v1, &interface->eswb_descriptors.in_v1);
if(rv != eswb_e_ok) {
error("failed connect input \"v1\" to topic \"%s\": %s", topic_path_in_v1, eswb_strerror(rv));
errcnt_no_topic++;
}
}
// Connecting optional input "v2"
if (topic_path_in_v2 != NULL) {
interface->i.optional_inputs_flags.v2 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v2, &interface->eswb_descriptors.in_v2);
if(rv != eswb_e_ok) {
error("failed connect input \"v2\" to topic \"%s\": %s", topic_path_in_v2, eswb_strerror(rv));
errcnt_no_topic++;
}
}
// Connecting optional input "v3"
if (topic_path_in_v3 != NULL) {
interface->i.optional_inputs_flags.v3 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v3, &interface->eswb_descriptors.in_v3);
if(rv != eswb_e_ok) {
error("failed connect input \"v3\" to topic \"%s\": %s", topic_path_in_v3, eswb_strerror(rv));
errcnt_no_topic++;
}
}
// Connecting optional input "v4"
if (topic_path_in_v4 != NULL) {
interface->i.optional_inputs_flags.v4 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v4, &interface->eswb_descriptors.in_v4);
if(rv != eswb_e_ok) {
error("failed connect input \"v4\" to topic \"%s\": %s", topic_path_in_v4, eswb_strerror(rv));
errcnt_no_topic++;
}
}
// Connecting optional input "v5"
if (topic_path_in_v5 != NULL) {
interface->i.optional_inputs_flags.v5 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v5, &interface->eswb_descriptors.in_v5);
if(rv != eswb_e_ok) {
error("failed connect input \"v5\" to topic \"%s\": %s", topic_path_in_v5, eswb_strerror(rv));
errcnt_no_topic++;
}
}
// Connecting optional input "v6"
if (topic_path_in_v6 != NULL) {
interface->i.optional_inputs_flags.v6 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v6, &interface->eswb_descriptors.in_v6);
if(rv != eswb_e_ok) {
error("failed connect input \"v6\" to topic \"%s\": %s", topic_path_in_v6, eswb_strerror(rv));
errcnt_no_topic++;
}
}
// Connecting optional input "v7"
if (topic_path_in_v7 != NULL) {
interface->i.optional_inputs_flags.v7 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v7, &interface->eswb_descriptors.in_v7);
if(rv != eswb_e_ok) {
error("failed connect input \"v7\" to topic \"%s\": %s", topic_path_in_v7, eswb_strerror(rv));
errcnt_no_topic++;
}
}
// Connecting optional input "v8"
if (topic_path_in_v8 != NULL) {
interface->i.optional_inputs_flags.v8 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v8, &interface->eswb_descriptors.in_v8);
if(rv != eswb_e_ok) {
error("failed connect input \"v8\" to topic \"%s\": %s", topic_path_in_v8, eswb_strerror(rv));
errcnt_no_topic++;
}
}
// Connecting optional input "v9"
if (topic_path_in_v9 != NULL) {
interface->i.optional_inputs_flags.v9 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v9, &interface->eswb_descriptors.in_v9);
if(rv != eswb_e_ok) {
error("failed connect input \"v9\" to topic \"%s\": %s", topic_path_in_v9, eswb_strerror(rv));
errcnt_no_topic++;
}
}
// Connecting optional input "v10"
if (topic_path_in_v10 != NULL) {
interface->i.optional_inputs_flags.v10 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v10, &interface->eswb_descriptors.in_v10);
if(rv != eswb_e_ok) {
error("failed connect input \"v10\" to topic \"%s\": %s", topic_path_in_v10, eswb_strerror(rv));
errcnt_no_topic++;
}
}
// Connecting optional input "v11"
if (topic_path_in_v11 != NULL) {
interface->i.optional_inputs_flags.v11 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v11, &interface->eswb_descriptors.in_v11);
if(rv != eswb_e_ok) {
error("failed connect input \"v11\" to topic \"%s\": %s", topic_path_in_v11, eswb_strerror(rv));
errcnt_no_topic++;
}
}
// Connecting optional input "v12"
if (topic_path_in_v12 != NULL) {
interface->i.optional_inputs_flags.v12 = 1;
rv = eswb_connect_nested(mounting_td, topic_path_in_v12, &interface->eswb_descriptors.in_v12);
if(rv != eswb_e_ok) {
error("failed connect input \"v12\" to topic \"%s\": %s", topic_path_in_v12, eswb_strerror(rv));
errcnt_no_topic++;
}
}
if ((errcnt_no_input > 0) || (errcnt_no_topic > 0)) {
if (errcnt_no_input > errcnt_no_topic) {
return fspec_rv_no_input;
} else {
return fspec_rv_no_topic;
}
}
return fspec_rv_ok;
}
fspec_rv_t cube_misc_cli_logger_interface_inputs_update(cube_misc_cli_logger_interface_t *interface)
{
eswb_rv_t rv;
if (interface->i.optional_inputs_flags.v1) {
rv = eswb_read(interface->eswb_descriptors.in_v1, &interface->i.v1);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
if (interface->i.optional_inputs_flags.v2) {
rv = eswb_read(interface->eswb_descriptors.in_v2, &interface->i.v2);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
if (interface->i.optional_inputs_flags.v3) {
rv = eswb_read(interface->eswb_descriptors.in_v3, &interface->i.v3);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
if (interface->i.optional_inputs_flags.v4) {
rv = eswb_read(interface->eswb_descriptors.in_v4, &interface->i.v4);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
if (interface->i.optional_inputs_flags.v5) {
rv = eswb_read(interface->eswb_descriptors.in_v5, &interface->i.v5);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
if (interface->i.optional_inputs_flags.v6) {
rv = eswb_read(interface->eswb_descriptors.in_v6, &interface->i.v6);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
if (interface->i.optional_inputs_flags.v7) {
rv = eswb_read(interface->eswb_descriptors.in_v7, &interface->i.v7);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
if (interface->i.optional_inputs_flags.v8) {
rv = eswb_read(interface->eswb_descriptors.in_v8, &interface->i.v8);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
if (interface->i.optional_inputs_flags.v9) {
rv = eswb_read(interface->eswb_descriptors.in_v9, &interface->i.v9);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
if (interface->i.optional_inputs_flags.v10) {
rv = eswb_read(interface->eswb_descriptors.in_v10, &interface->i.v10);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
if (interface->i.optional_inputs_flags.v11) {
rv = eswb_read(interface->eswb_descriptors.in_v11, &interface->i.v11);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
if (interface->i.optional_inputs_flags.v12) {
rv = eswb_read(interface->eswb_descriptors.in_v12, &interface->i.v12);
if(rv != eswb_e_ok) {
/*FIXME nothing to do yet*/
}
}
return 0;
}
void cube_misc_cli_logger_interface_update(cube_misc_cli_logger_interface_t *interface)
{
cube_misc_cli_logger_interface_inputs_update(interface);
cube_misc_cli_logger_exec(&interface->i);
}
fspec_rv_t cube_misc_cli_logger_call_init_inputs(
void *dh,
const func_conn_spec_t *conn_spec,
eswb_topic_descr_t mounting_td
)
{
cube_misc_cli_logger_interface_t *interface = (cube_misc_cli_logger_interface_t*) dh;
return cube_misc_cli_logger_interface_inputs_init(interface, conn_spec, mounting_td);
}
void cube_misc_cli_logger_call_exec(void *dh)
{
cube_misc_cli_logger_interface_t *interface = (cube_misc_cli_logger_interface_t*) dh;
cube_misc_cli_logger_interface_update(interface);
}