core.math.inverse_gain¶

Inputs¶

Name	Type	Title	Mandatory	Description
input	core.type.f64	Input	True	None

Outputs¶

Name	Type	Title	Description
output	core.type.f64	Output	None

Parameters¶

Name	Type	Title	Mandatory	Default value	Description
inverse_gain	core.type.f64	Inverse gain	True	None	None
gain	core.type.f64	Gain	False	None	None

State variables¶

Function has no state variables

Usage XML code snippet¶

core_math_inverse_gain snippet for FLOW configuration file¶

<f name="inverse_gain" by_spec="core.math.inverse_gain">
    <in alias="input">some_block_1/output</in>
    <param alias="inverse_gain">0.0</param>
    <param alias="gain">0.0</param>   <!-- optional -->
</f>

Function’s artifacts¶

Declaration for core_math_inverse_gain
Implementation for core_math_inverse_gain
Params computing implemtation for core_math_inverse_gain
Set parameters code for core_math_inverse_gain
Header of core_math_inverse_gain
Other
- Specification of core_math_inverse_gain
- Interface of core_math_inverse_gain

declaration.py¶

from fspeclib import *


Function(
    name='core.math.inverse_gain',
    title=LocalizedString(
        en='Gain of number'
    ),
    parameters=[
      Parameter(
          name='inverse_gain',
          title='Inverse gain',
          value_type='core.type.f64',
      ),
      ComputedParameter(
          name='gain',
          title='Gain',
          value_type='core.type.f64'
      )
    ],
    inputs=[
        Input(
            name='input',
            title='Input',
            value_type='core.type.f64'
        )
    ],
    outputs=[
        Output(
            name='output',
            title='Output',
            value_type='core.type.f64'
        )
    ]
)

core_math_inverse_gain_exec.c¶

#include "core_math_inverse_gain.h"

void core_math_inverse_gain_exec(
    const core_math_inverse_gain_inputs_t *i,
    core_math_inverse_gain_outputs_t *o,
    const core_math_inverse_gain_params_t *p
)
{
    o->output = i->input * p->inverse_gain;
}

core_math_inverse_gain_compute_params.c¶

#include "core_math_inverse_gain.h"

void core_math_inverse_gain_compute_params(
    core_math_inverse_gain_params_t *old_p,
    core_math_inverse_gain_params_t *new_p,
    core_math_inverse_gain_params_flags_t *flags
)
{
    new_p->gain = 1.0 / new_p->inverse_gain;
}

core_math_inverse_gain_set_params.c¶

#include "core_math_inverse_gain.h"
#include "conv.h"

#include <string.h>

#include "error.h"

fspec_rv_t core_math_inverse_gain_set_params(
    core_math_inverse_gain_params_t *params,
    const func_param_t *param_pairs,
    int initial_call
)
{
    // Get parameters
    core_math_inverse_gain_params_t p = *params;

    core_math_inverse_gain_params_flags_t flags;
    memset(&flags, 0, sizeof(flags));

    int violation_count = 0;
    conv_rv_t crv = conv_rv_ok;

    // Parse parameters
    for (int i = 0; param_pairs[i].alias != NULL; i++) {
        if (strcmp(param_pairs[i].alias, "inverse_gain") == 0) {
            if ((crv = conv_str_double(param_pairs[i].value, &p.inverse_gain)) == conv_rv_ok) {
                flags.changed_param_inverse_gain = 1;
            }
        } else if (strcmp(param_pairs[i].alias, "gain") == 0) {
            if ((crv = conv_str_double(param_pairs[i].value, &p.gain)) == conv_rv_ok) {
                flags.changed_param_gain = 1;
            }
        } else {
            error("failed unsupported parameter '%s'", param_pairs[i].alias);
            violation_count ++;
        }

        if (crv != conv_rv_ok) {
            error("Parameter '%s' format error (%s)", param_pairs[i].alias, param_pairs[i].value);
            violation_count++;
        }
    }

    if (initial_call) {
        // Check all mandatory parameters are set
        if (!flags.changed_param_inverse_gain) {
            error("failed missed mandatory parameter 'inverse_gain'");
            violation_count ++;
        }
    }

    if (violation_count > 0) {
        return fspec_rv_inval_param;
    }

    // Compute parameters
    core_math_inverse_gain_compute_params(params, &p, &flags);

    // Set parameters
    *params = p;

    return fspec_rv_ok;
}

core_math_inverse_gain.h¶

/**
 *  Automatically-generated file. Do not edit!
 */

#ifndef FSPEC_CORE_MATH_INVERSE_GAIN_H
#define FSPEC_CORE_MATH_INVERSE_GAIN_H

#include <stdint.h>
#include <eswb/types.h>

#include "function.h"

/* Include declaration of dependency types */
#include "core_type_f64.h"

/**
 * @brief Parameters of `core.math.inverse_gain` function
 */
typedef struct core_math_inverse_gain_params_{
    core_type_f64_t inverse_gain;  /// Inverse gain
    core_type_f64_t gain;  /// Gain
} core_math_inverse_gain_params_t;

/**
 * @brief Inputs of `core.math.inverse_gain` function
 */
typedef struct core_math_inverse_gain_inputs_ {
    core_type_f64_t input;  /// Input

} core_math_inverse_gain_inputs_t;

/**
 * @brief Outputs of `core.math.inverse_gain` function
 */
typedef struct core_math_inverse_gain_outputs_ {
    core_type_f64_t output; /// Output

} core_math_inverse_gain_outputs_t;

/**
 * @brief Parameter flags of `core.math.inverse_gain` function
 */
typedef struct core_math_inverse_gain_params_flags_ {
    uint64_t changed_param_inverse_gain:1;
    uint64_t changed_param_gain:1;
} core_math_inverse_gain_params_flags_t;

typedef struct core_math_inverse_gain_eswb_descriptors_ {
    eswb_topic_descr_t in_input;
    eswb_topic_descr_t out_all;
} core_math_inverse_gain_eswb_descriptors_t;

typedef struct core_math_inverse_gain_interface_ {
    core_math_inverse_gain_inputs_t i;
    core_math_inverse_gain_outputs_t o;
    core_math_inverse_gain_params_t p;
    core_math_inverse_gain_eswb_descriptors_t eswb_descriptors;
} core_math_inverse_gain_interface_t;

fspec_rv_t core_math_inverse_gain_set_params(
    core_math_inverse_gain_params_t *params,
    const func_param_t *param_pairs,
    int initial_call
);

void core_math_inverse_gain_compute_params(
    core_math_inverse_gain_params_t *old_p,
    core_math_inverse_gain_params_t *new_p,
    core_math_inverse_gain_params_flags_t *flags
);

void core_math_inverse_gain_exec(
    const core_math_inverse_gain_inputs_t *i,
    core_math_inverse_gain_outputs_t *o,
    const core_math_inverse_gain_params_t *p
);

#endif // FSPEC_CORE_MATH_INVERSE_GAIN_H

core_math_inverse_gain_spec.c¶

/**
 *  Automatically-generated file. Do not edit!
 */

#include "core_math_inverse_gain.h"
#include <eswb/types.h>

static const param_spec_t param_inverse_gain = {
    .name = "inverse_gain",
    .default_value = "0.0",
    .annotation = "Inverse gain",
    .flags = 0
};

static const param_spec_t param_gain = {
    .name = "gain",
    .default_value = "0.0",
    .annotation = "Gain",
    .flags = 0
};

static const param_spec_t *params[3] = {
    &param_inverse_gain,
    &param_gain,
    NULL
};

static const input_spec_t i_input = {
    .name = "input",
    .annotation = "Input",
    .flags = 0
};

static const input_spec_t *inputs[2] = {
    &i_input,
    NULL
};

static const output_spec_t o_output = {
    .name = "output",
    .annotation = "Output",
    .flags = 0
};

static const output_spec_t *outputs[2] = {
    &o_output,
    NULL
};

fspec_rv_t core_math_inverse_gain_call_init_inputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td
);

fspec_rv_t core_math_inverse_gain_call_init_outputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td,
    const char *func_name
);

void core_math_inverse_gain_call_exec(void *dh);

fspec_rv_t core_math_inverse_gain_call_set_params(void *dh, const func_param_t *param_pairs, int initial_call);

const function_spec_t atomic_core_math_inverse_gain_spec = {
    .name = "core.math.inverse_gain",
    .annotation = "Gain of number",
    .inputs = inputs,
    .outputs = outputs,
    .params = params
};

const function_calls_t atomic_core_math_inverse_gain_calls = {
    .interface_handle_size = sizeof(core_math_inverse_gain_interface_t),
    .init = NULL,
    .init_inputs = core_math_inverse_gain_call_init_inputs,
    .init_outputs = core_math_inverse_gain_call_init_outputs,
    .pre_exec_init = NULL,
    .exec = core_math_inverse_gain_call_exec,
    .set_params = core_math_inverse_gain_call_set_params
};

const function_handler_t atomic_core_math_inverse_gain_handler = {
    .spec = &atomic_core_math_inverse_gain_spec,
    .calls = &atomic_core_math_inverse_gain_calls,
    .extension_handler = NULL
};

core_math_inverse_gain_interface.c¶

/**
 *  Automatically-generated file. Do not edit!
 */

#include "core_math_inverse_gain.h"

#include "error.h"
#include <eswb/api.h>
#include <eswb/topic_proclaiming_tree.h>
#include <eswb/errors.h>

int core_math_inverse_gain_interface_inputs_init(
    core_math_inverse_gain_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_input = fspec_find_path2connect(conn_spec,"input");

    // Connecting mandatory input "input"
    if (topic_path_in_input != NULL) {
        rv = eswb_connect_nested(mounting_td, topic_path_in_input, &interface->eswb_descriptors.in_input);
        if(rv != eswb_e_ok) {
            error("failed connect input \"input\" to topic \"%s\": %s", topic_path_in_input, eswb_strerror(rv));
            errcnt_no_topic++;
        }
    } else {
        error("mandatory input \"input\" is not speicifed");
        errcnt_no_input++;
    }

    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 core_math_inverse_gain_interface_inputs_update(core_math_inverse_gain_interface_t *interface)
{
    eswb_rv_t rv;

    rv = eswb_read(interface->eswb_descriptors.in_input, &interface->i.input);
    if(rv != eswb_e_ok) {
        /*FIXME nothing to do yet*/
    }

    return 0;
}

fspec_rv_t core_math_inverse_gain_interface_outputs_init(
    core_math_inverse_gain_interface_t *interface,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td,
    const char *func_name
)
{
    TOPIC_TREE_CONTEXT_LOCAL_DEFINE(cntx, 2);
    core_math_inverse_gain_outputs_t out;
    eswb_rv_t rv;

    topic_proclaiming_tree_t *rt = usr_topic_set_struct(cntx, out, func_name);

    usr_topic_add_struct_child(cntx, rt, core_math_inverse_gain_outputs_t, output, "output", tt_double);
    rv = eswb_proclaim_tree(mounting_td, rt, cntx->t_num, &interface->eswb_descriptors.out_all);
    if (rv != eswb_e_ok) {
        return fspec_rv_publish_err;
    }

    return fspec_rv_ok;
}

fspec_rv_t core_math_inverse_gain_interface_outputs_update(core_math_inverse_gain_interface_t *interface)
{
    eswb_rv_t rv;

    rv = eswb_update_topic(interface->eswb_descriptors.out_all, &interface->o);
    if (rv != eswb_e_ok) {
        return 1;
    }

    return 0;
}

void core_math_inverse_gain_interface_update(core_math_inverse_gain_interface_t *interface)
{
    core_math_inverse_gain_interface_inputs_update(interface);
    core_math_inverse_gain_exec(&interface->i, &interface->o, &interface->p);
    core_math_inverse_gain_interface_outputs_update(interface);
}

fspec_rv_t core_math_inverse_gain_call_set_params(void *dh, const func_param_t *param_pairs, int initial_call)
{
    core_math_inverse_gain_interface_t *interface = (core_math_inverse_gain_interface_t*) dh;
    return core_math_inverse_gain_set_params(&interface->p, param_pairs, initial_call);
}

fspec_rv_t core_math_inverse_gain_call_init_inputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td
)
{
    core_math_inverse_gain_interface_t *interface = (core_math_inverse_gain_interface_t*) dh;
    return core_math_inverse_gain_interface_inputs_init(interface, conn_spec, mounting_td);
}

fspec_rv_t core_math_inverse_gain_call_init_outputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td,
    const char *func_name
)
{
    core_math_inverse_gain_interface_t *interface = (core_math_inverse_gain_interface_t*) dh;
    return core_math_inverse_gain_interface_outputs_init(interface, conn_spec, mounting_td, func_name);
}

void core_math_inverse_gain_call_exec(void *dh)
{
    core_math_inverse_gain_interface_t *interface = (core_math_inverse_gain_interface_t*) dh;
    core_math_inverse_gain_interface_update(interface);
}

← core.math.in_range core.math.lerp →