core.source.meander¶

Inputs¶

Function has no inputs

Outputs¶

Name	Type	Title	Description
output	core.type.f64	Output	Meander generator output

Parameters¶

Name	Type	Title	Mandatory	Default value	Description
semi_period	core.type.u32	Meadner semi period in cycles (calls number)	True	None	None

State variables¶

Name	Type	Title	Description
counter	core.type.u32	Meander counter	None
state	core.type.bool	Meander state	None

Usage XML code snippet¶

core_source_meander snippet for FLOW configuration file¶

<f name="meander" by_spec="core.source.meander">
    <param alias="semi_period">0.0</param>
</f>

Function’s artifacts¶

Declaration for core_source_meander
Implementation for core_source_meander
Set parameters code for core_source_meander
Header of core_source_meander
Specification of core_source_meander
Other
- Interface of core_source_meander

declaration.py¶

from fspeclib import *

Function(
    name='core.source.meander',
    title=LocalizedString(
        en='Meander with constant period'
    ),
    description=None,
    parameters=[
        Parameter(
            name='semi_period',
            title='Meadner semi period in cycles (calls number)',
            value_type='core.type.u32',
            constraints=[
                ThisValue() > 0
            ]
        ),
    ],
    outputs=[
        Output(
            name='output',
            title='Output',
            description='Meander generator output',
            value_type='core.type.f64'
        )
    ],
    state=[
        Variable(
            name='counter',
            title='Meander counter',
            value_type='core.type.u32'
        ),
        Variable(
            name='state',
            title='Meander state',
            value_type='core.type.bool'
        )
    ]
)

core_source_meander_exec.c¶

#include "core_source_meander.h"

void core_source_meander_exec(
    core_source_meander_outputs_t *o,
    const core_source_meander_params_t *p,
    core_source_meander_state_t *state
)
{
    state->counter++;
    if(state->counter >= p->semi_period) {
        state->counter = 0;
        if (state->state) {
            state->state = FALSE;
        } else {
            state->state = TRUE;
        }
    }

    o->output = state->state ? 1.0 : 0.0;
}

core_source_meander_set_params.c¶

#include "core_source_meander.h"
#include "conv.h"

#include <string.h>

#include "error.h"

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

    core_source_meander_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, "semi_period") == 0) {
            if ((crv = conv_str_uint32(param_pairs[i].value, &p.semi_period)) == conv_rv_ok) {
                flags.changed_param_semi_period = 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_semi_period) {
            error("failed missed mandatory parameter 'semi_period'");
            violation_count ++;
        }
    }

    if (violation_count > 0) {
        return fspec_rv_inval_param;
    }

    // Validate parameters
    if (!(p.semi_period > 0)) {
        error("failed constraint (semi_period > 0)");
        return fspec_rv_inval_param;
    }

    // Set parameters
    *params = p;

    return fspec_rv_ok;
}

core_source_meander.h¶

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

#ifndef FSPEC_CORE_SOURCE_MEANDER_H
#define FSPEC_CORE_SOURCE_MEANDER_H

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

#include "function.h"

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

/**
 * @brief Parameters of `core.source.meander` function
 */
typedef struct core_source_meander_params_{
    core_type_u32_t semi_period;  /// Meadner semi period in cycles (calls number)
} core_source_meander_params_t;

/**
 * @brief Outputs of `core.source.meander` function
 */
typedef struct core_source_meander_outputs_ {
    core_type_f64_t output; /// Output

} core_source_meander_outputs_t;

/**
 * @brief State variables of `core.source.meander` function
 */
typedef struct core_source_meander_state_ {
    core_type_u32_t counter;  /// Meander counter
    core_type_bool_t state;  /// Meander state
} core_source_meander_state_t;

/**
 * @brief Parameter flags of `core.source.meander` function
 */
typedef struct core_source_meander_params_flags_ {
    uint64_t changed_param_semi_period:1;
} core_source_meander_params_flags_t;

typedef struct core_source_meander_eswb_descriptors_ {
    eswb_topic_descr_t out_all;
} core_source_meander_eswb_descriptors_t;

typedef struct core_source_meander_interface_ {
    core_source_meander_outputs_t o;
    core_source_meander_params_t p;
    core_source_meander_state_t state;
    core_source_meander_eswb_descriptors_t eswb_descriptors;
} core_source_meander_interface_t;

fspec_rv_t core_source_meander_set_params(
    core_source_meander_params_t *params,
    const func_param_t *param_pairs,
    int initial_call
);

void core_source_meander_exec(
    core_source_meander_outputs_t *o,
    const core_source_meander_params_t *p,
    core_source_meander_state_t *state
);

#endif // FSPEC_CORE_SOURCE_MEANDER_H

core_source_meander_spec.c¶

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

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

static const param_spec_t param_semi_period = {
    .name = "semi_period",
    .default_value = "0.0",
    .annotation = "Meadner semi period in cycles (calls number)",
    .flags = 0
};

static const param_spec_t *params[2] = {
    &param_semi_period,
    NULL
};

static const input_spec_t *inputs[1] = {
    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_source_meander_call_init_outputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td,
    const char *func_name
);

void core_source_meander_call_exec(void *dh);

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

const function_spec_t atomic_core_source_meander_spec = {
    .name = "core.source.meander",
    .annotation = "Meander with constant period",
    .inputs = inputs,
    .outputs = outputs,
    .params = params
};

const function_calls_t atomic_core_source_meander_calls = {
    .interface_handle_size = sizeof(core_source_meander_interface_t),
    .init = NULL,
    .init_inputs = NULL,
    .init_outputs = core_source_meander_call_init_outputs,
    .pre_exec_init = NULL,
    .exec = core_source_meander_call_exec,
    .set_params = core_source_meander_call_set_params
};

const function_handler_t atomic_core_source_meander_handler = {
    .spec = &atomic_core_source_meander_spec,
    .calls = &atomic_core_source_meander_calls,
    .extension_handler = NULL
};

core_source_meander_interface.c¶

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

#include "core_source_meander.h"

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

fspec_rv_t core_source_meander_interface_outputs_init(
    core_source_meander_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_source_meander_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_source_meander_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_source_meander_interface_outputs_update(core_source_meander_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_source_meander_interface_update(core_source_meander_interface_t *interface)
{
    core_source_meander_exec(&interface->o, &interface->p, &interface->state);
    core_source_meander_interface_outputs_update(interface);
}

fspec_rv_t core_source_meander_call_set_params(void *dh, const func_param_t *param_pairs, int initial_call)
{
    core_source_meander_interface_t *interface = (core_source_meander_interface_t*) dh;
    return core_source_meander_set_params(&interface->p, param_pairs, initial_call);
}

fspec_rv_t core_source_meander_call_init_outputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td,
    const char *func_name
)
{
    core_source_meander_interface_t *interface = (core_source_meander_interface_t*) dh;
    return core_source_meander_interface_outputs_init(interface, conn_spec, mounting_td, func_name);
}

void core_source_meander_call_exec(void *dh)
{
    core_source_meander_interface_t *interface = (core_source_meander_interface_t*) dh;
    core_source_meander_interface_update(interface);
}

← core.source.constant core.source.sin →