• Atomic functions catalog >
• cube.io.gpio

cube.io.gpio

Inputs

Name	Type	Title	Mandatory	Description
input_bool	core.type.bool	input bool	False	None
input_float	core.type.f64	input float 64	False	None

Outputs

Name	Type	Title	Description
out	core.type.bool	out	None

Parameters

Name	Type	Title	Mandatory	Default value	Description
channel	core.type.u8	channel	False	0	None

State variables

Function has no state variables

Usage XML code snippet

cube_io_gpio snippet for FLOW configuration file

<f name="gpio" by_spec="cube.io.gpio">
    <in alias="input_bool">some_block_1/output</in>   <!-- optional -->
    <in alias="input_float">some_block_2/output</in>   <!-- optional -->
    <param alias="channel">0.0</param>   <!-- optional -->
</f>

Function’s artifacts

• Declaration for cube_io_gpio
• Implementation for cube_io_gpio
• Set parameters code for cube_io_gpio
• Header of cube_io_gpio
• Specification of cube_io_gpio
• Other
  • Interface of cube_io_gpio

declaration.py

from fspeclib import *

Function(
    name='cube.io.gpio',
    title=LocalizedString(
        en='gpio'
    ),
    parameters=[
        Parameter(
            name='channel',
            title='channel',
            value_type='core.type.u8',
            tunable=True,
            default=0,
        )
    ],
    inputs=[
        Input(
            name='input_bool',
            title='input bool',
            value_type='core.type.bool',
            mandatory=False,
        ),
        Input(
            name='input_float',
            title='input float 64',
            value_type='core.type.f64',
            mandatory=False
        ),
    ],
    outputs=[
        Output(
            name='out',
            title='out',
            value_type='core.type.bool'
        ),
    ],
    state=[],
    parameter_constraints=[],
)

cube_io_gpio_exec.c

#include "cube_io_gpio.h"
#include "board.h"

void cube_io_gpio_exec(const cube_io_gpio_inputs_t *i, cube_io_gpio_outputs_t *o, const cube_io_gpio_params_t *p)
{
    if(p->channel < 1 || p->channel > 6) return;

    if(i->optional_inputs_flags.input_bool) {
        gpio_set_state(&gpio_fmu_pwm[p->channel - 1], i->input_bool);
    } if (i->optional_inputs_flags.input_float) {
        gpio_set_state(&gpio_fmu_pwm[p->channel - 1],
                      i->input_float > 0.5 ? 1 : 0);
    } else {
        gpio_toggle(&gpio_fmu_pwm[p->channel - 1]);
    }
}

void test_gpio5_set() {
    gpio_set_state(&gpio_fmu_pwm[5], 1);
}

void test_gpio5_clear() {
    gpio_set_state(&gpio_fmu_pwm[5], 0);
}

cube_io_gpio_set_params.c

#include "cube_io_gpio.h"
#include "conv.h"

#include <string.h>

#include "error.h"

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

    cube_io_gpio_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, "channel") == 0) {
            if ((crv = conv_str_uint8(param_pairs[i].value, &p.channel)) == conv_rv_ok) {
                flags.changed_param_channel = 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) {
        // Set default value for non mandatory parameters which are not set
        if (!flags.changed_param_channel) {
            p.channel = 0;
            flags.changed_param_channel = 1;
        }
    }

    if (violation_count > 0) {
        return fspec_rv_inval_param;
    }

    // Set parameters
    *params = p;

    return fspec_rv_ok;
}

cube_io_gpio.h

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

#ifndef FSPEC_CUBE_IO_GPIO_H
#define FSPEC_CUBE_IO_GPIO_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_u8.h"

/**
 * @brief Parameters of `cube.io.gpio` function
 */
typedef struct cube_io_gpio_params_{
    core_type_u8_t channel;  /// channel
} cube_io_gpio_params_t;

/**
 * @brief Optional inputs connectivity flags structure for `cube.io.gpio` function
 */
typedef struct {
    uint32_t input_bool:1;
    uint32_t input_float:1;
} cube_io_gpio_optional_inputs_flags_t;

/**
 * @brief Inputs of `cube.io.gpio` function
 */
typedef struct cube_io_gpio_inputs_ {
    core_type_bool_t input_bool;  /// input bool
    core_type_f64_t input_float;  /// input float 64

    cube_io_gpio_optional_inputs_flags_t optional_inputs_flags;
} cube_io_gpio_inputs_t;

/**
 * @brief Outputs of `cube.io.gpio` function
 */
typedef struct cube_io_gpio_outputs_ {
    core_type_bool_t out; /// out

} cube_io_gpio_outputs_t;

/**
 * @brief Parameter flags of `cube.io.gpio` function
 */
typedef struct cube_io_gpio_params_flags_ {
    uint64_t changed_param_channel:1;
} cube_io_gpio_params_flags_t;

typedef struct cube_io_gpio_eswb_descriptors_ {
    eswb_topic_descr_t in_input_bool;
    eswb_topic_descr_t in_input_float;
    eswb_topic_descr_t out_all;
} cube_io_gpio_eswb_descriptors_t;

typedef struct cube_io_gpio_interface_ {
    cube_io_gpio_inputs_t i;
    cube_io_gpio_outputs_t o;
    cube_io_gpio_params_t p;
    cube_io_gpio_eswb_descriptors_t eswb_descriptors;
} cube_io_gpio_interface_t;

fspec_rv_t cube_io_gpio_set_params(cube_io_gpio_params_t *params, const func_param_t *param_pairs, int initial_call);

void cube_io_gpio_exec(const cube_io_gpio_inputs_t *i, cube_io_gpio_outputs_t *o, const cube_io_gpio_params_t *p);

#endif // FSPEC_CUBE_IO_GPIO_H

cube_io_gpio_spec.c

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

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

static const param_spec_t param_channel = {
    .name = "channel",
    .default_value = "0.0",
    .annotation = "channel",
    .flags = 0
};

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

static const input_spec_t i_input_bool = {
    .name = "input_bool",
    .annotation = "input bool",
    .flags = 0
};

static const input_spec_t i_input_float = {
    .name = "input_float",
    .annotation = "input float 64",
    .flags = 0
};

static const input_spec_t *inputs[3] = {
    &i_input_bool,
    &i_input_float,
    NULL
};

static const output_spec_t o_out = {
    .name = "out",
    .annotation = "out",
    .flags = 0
};

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

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

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

void cube_io_gpio_call_exec(void *dh);

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

const function_spec_t atomic_cube_io_gpio_spec = {
    .name = "cube.io.gpio",
    .annotation = "gpio",
    .inputs = inputs,
    .outputs = outputs,
    .params = params
};

const function_calls_t atomic_cube_io_gpio_calls = {
    .interface_handle_size = sizeof(cube_io_gpio_interface_t),
    .init = NULL,
    .init_inputs = cube_io_gpio_call_init_inputs,
    .init_outputs = cube_io_gpio_call_init_outputs,
    .pre_exec_init = NULL,
    .exec = cube_io_gpio_call_exec,
    .set_params = cube_io_gpio_call_set_params
};

const function_handler_t atomic_cube_io_gpio_handler = {
    .spec = &atomic_cube_io_gpio_spec,
    .calls = &atomic_cube_io_gpio_calls,
    .extension_handler = NULL
};

cube_io_gpio_interface.c

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

#include "cube_io_gpio.h"

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

int cube_io_gpio_interface_inputs_init(
    cube_io_gpio_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_bool = fspec_find_path2connect(conn_spec,"input_bool");
    const char *topic_path_in_input_float = fspec_find_path2connect(conn_spec,"input_float");

    // Connecting optional input "input_bool"
    if (topic_path_in_input_bool != NULL) {
        interface->i.optional_inputs_flags.input_bool = 1;
        rv = eswb_connect_nested(mounting_td, topic_path_in_input_bool, &interface->eswb_descriptors.in_input_bool);
        if(rv != eswb_e_ok) {
            error("failed connect input \"input_bool\" to topic \"%s\": %s", topic_path_in_input_bool, eswb_strerror(rv));
            errcnt_no_topic++;
        }
    }

    // Connecting optional input "input_float"
    if (topic_path_in_input_float != NULL) {
        interface->i.optional_inputs_flags.input_float = 1;
        rv = eswb_connect_nested(mounting_td, topic_path_in_input_float, &interface->eswb_descriptors.in_input_float);
        if(rv != eswb_e_ok) {
            error("failed connect input \"input_float\" to topic \"%s\": %s", topic_path_in_input_float, 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_io_gpio_interface_inputs_update(cube_io_gpio_interface_t *interface)
{
    eswb_rv_t rv;

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

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

    return 0;
}

fspec_rv_t cube_io_gpio_interface_outputs_init(
    cube_io_gpio_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);
    cube_io_gpio_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, cube_io_gpio_outputs_t, out, "out", tt_int32);
    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 cube_io_gpio_interface_outputs_update(cube_io_gpio_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 cube_io_gpio_interface_update(cube_io_gpio_interface_t *interface)
{
    cube_io_gpio_interface_inputs_update(interface);
    cube_io_gpio_exec(&interface->i, &interface->o, &interface->p);
    cube_io_gpio_interface_outputs_update(interface);
}

fspec_rv_t cube_io_gpio_call_set_params(void *dh, const func_param_t *param_pairs, int initial_call)
{
    cube_io_gpio_interface_t *interface = (cube_io_gpio_interface_t*) dh;
    return cube_io_gpio_set_params(&interface->p, param_pairs, initial_call);
}

fspec_rv_t cube_io_gpio_call_init_inputs(void *dh, const func_conn_spec_t *conn_spec, eswb_topic_descr_t mounting_td)
{
    cube_io_gpio_interface_t *interface = (cube_io_gpio_interface_t*) dh;
    return cube_io_gpio_interface_inputs_init(interface, conn_spec, mounting_td);
}

fspec_rv_t cube_io_gpio_call_init_outputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td,
    const char *func_name
)
{
    cube_io_gpio_interface_t *interface = (cube_io_gpio_interface_t*) dh;
    return cube_io_gpio_interface_outputs_init(interface, conn_spec, mounting_td, func_name);
}

void cube_io_gpio_call_exec(void *dh)
{
    cube_io_gpio_interface_t *interface = (cube_io_gpio_interface_t*) dh;
    cube_io_gpio_interface_update(interface);
}

←   Atomic functions catalog cube.io.pwm  →

© Catalyst Aerospace Technologies