cube.sensors.icm20649¶

Inputs¶

Function has no inputs

Outputs¶

Name	Type	Title	Description
ax	core.type.f64	X-axis acceleration	None
ay	core.type.f64	Y-axis acceleration	None
az	core.type.f64	Z-axis acceleration	None
wx	core.type.f64	X-axis angular rate	None
wy	core.type.f64	Y-axis angular rate	None
wz	core.type.f64	Z-axis angular rate	None

Parameters¶

Function has no parameters

State variables¶

Function has no state variables

Usage XML code snippet¶

cube_sensors_icm20649 snippet for FLOW configuration file¶

<f name="icm20649" by_spec="cube.sensors.icm20649">
</f>

Function’s artifacts¶

Declaration for cube_sensors_icm20649
Implementation for cube_sensors_icm20649
Header of cube_sensors_icm20649
Specification of cube_sensors_icm20649
Interface of cube_sensors_icm20649

declaration.py¶

from fspeclib import *

Function(
    name='cube.sensors.icm20649',
    title=LocalizedString(
        en='icm20649'
    ),
    parameters=[],
    inputs=[],
    outputs=[
        Output(
            name='ax',
            title='X-axis acceleration',
            value_type='core.type.f64'
        ),
        Output(
            name='ay',
            title='Y-axis acceleration',
            value_type='core.type.f64'
        ),
        Output(
            name='az',
            title='Z-axis acceleration',
            value_type='core.type.f64'
        ),
        Output(
            name='wx',
            title='X-axis angular rate',
            value_type='core.type.f64'
        ),
        Output(
            name='wy',
            title='Y-axis angular rate',
            value_type='core.type.f64'
        ),
        Output(
            name='wz',
            title='Z-axis angular rate',
            value_type='core.type.f64'
        ),
    ],
    state=[],
    parameter_constraints=[]
)

cube_sensors_icm20649_exec.c¶

#include <math.h>
#include "cube_sensors_icm20649.h"
#include "board.h"

#define deg2rad(d) ((d) * (M_PI / 180.0))

void cube_sensors_icm20649_exec(cube_sensors_icm20649_outputs_t *o)
{
    gpio_set(&gpio_fmu_pwm[0]);

    icm20649_meas_t meas;

    icm20649_get_meas_block(icm20649, &meas);

    o->wx = deg2rad(meas.gyro_x);
    o->wy = deg2rad(meas.gyro_y);
    o->wz = deg2rad(meas.gyro_z);

    o->ax = -meas.accel_x;
    o->ay = -meas.accel_y;
    o->az = -meas.accel_z;

    gpio_reset(&gpio_fmu_pwm[0]);
}

cube_sensors_icm20649.h¶

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

#ifndef FSPEC_CUBE_SENSORS_ICM20649_H
#define FSPEC_CUBE_SENSORS_ICM20649_H

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

#include "function.h"

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

/**
 * @brief Outputs of `cube.sensors.icm20649` function
 */
typedef struct cube_sensors_icm20649_outputs_ {
    core_type_f64_t ax; /// X-axis acceleration

    core_type_f64_t ay; /// Y-axis acceleration

    core_type_f64_t az; /// Z-axis acceleration

    core_type_f64_t wx; /// X-axis angular rate

    core_type_f64_t wy; /// Y-axis angular rate

    core_type_f64_t wz; /// Z-axis angular rate

} cube_sensors_icm20649_outputs_t;

typedef struct cube_sensors_icm20649_eswb_descriptors_ {
    eswb_topic_descr_t out_all;
} cube_sensors_icm20649_eswb_descriptors_t;

typedef struct cube_sensors_icm20649_interface_ {
    cube_sensors_icm20649_outputs_t o;
    cube_sensors_icm20649_eswb_descriptors_t eswb_descriptors;
} cube_sensors_icm20649_interface_t;

void cube_sensors_icm20649_exec(cube_sensors_icm20649_outputs_t *o);

#endif // FSPEC_CUBE_SENSORS_ICM20649_H

cube_sensors_icm20649_spec.c¶

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

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

static const param_spec_t *params[1] = {
    NULL
};

static const input_spec_t *inputs[1] = {
    NULL
};

static const output_spec_t o_ax = {
    .name = "ax",
    .annotation = "X-axis acceleration",
    .flags = 0
};

static const output_spec_t o_ay = {
    .name = "ay",
    .annotation = "Y-axis acceleration",
    .flags = 0
};

static const output_spec_t o_az = {
    .name = "az",
    .annotation = "Z-axis acceleration",
    .flags = 0
};

static const output_spec_t o_wx = {
    .name = "wx",
    .annotation = "X-axis angular rate",
    .flags = 0
};

static const output_spec_t o_wy = {
    .name = "wy",
    .annotation = "Y-axis angular rate",
    .flags = 0
};

static const output_spec_t o_wz = {
    .name = "wz",
    .annotation = "Z-axis angular rate",
    .flags = 0
};

static const output_spec_t *outputs[7] = {
    &o_ax,
    &o_ay,
    &o_az,
    &o_wx,
    &o_wy,
    &o_wz,
    NULL
};

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

void cube_sensors_icm20649_call_exec(void *dh);

const function_spec_t atomic_cube_sensors_icm20649_spec = {
    .name = "cube.sensors.icm20649",
    .annotation = "icm20649",
    .inputs = inputs,
    .outputs = outputs,
    .params = params
};

const function_calls_t atomic_cube_sensors_icm20649_calls = {
    .interface_handle_size = sizeof(cube_sensors_icm20649_interface_t),
    .init = NULL,
    .init_inputs = NULL,
    .init_outputs = cube_sensors_icm20649_call_init_outputs,
    .pre_exec_init = NULL,
    .exec = cube_sensors_icm20649_call_exec,
    .set_params = NULL
};

const function_handler_t atomic_cube_sensors_icm20649_handler = {
    .spec = &atomic_cube_sensors_icm20649_spec,
    .calls = &atomic_cube_sensors_icm20649_calls,
    .extension_handler = NULL
};

cube_sensors_icm20649_interface.c¶

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

#include "cube_sensors_icm20649.h"

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

fspec_rv_t cube_sensors_icm20649_interface_outputs_init(
    cube_sensors_icm20649_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, 7);
    cube_sensors_icm20649_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_sensors_icm20649_outputs_t, ax, "ax", tt_double);
    usr_topic_add_struct_child(cntx, rt, cube_sensors_icm20649_outputs_t, ay, "ay", tt_double);
    usr_topic_add_struct_child(cntx, rt, cube_sensors_icm20649_outputs_t, az, "az", tt_double);
    usr_topic_add_struct_child(cntx, rt, cube_sensors_icm20649_outputs_t, wx, "wx", tt_double);
    usr_topic_add_struct_child(cntx, rt, cube_sensors_icm20649_outputs_t, wy, "wy", tt_double);
    usr_topic_add_struct_child(cntx, rt, cube_sensors_icm20649_outputs_t, wz, "wz", 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 cube_sensors_icm20649_interface_outputs_update(cube_sensors_icm20649_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_sensors_icm20649_interface_update(cube_sensors_icm20649_interface_t *interface)
{
    cube_sensors_icm20649_exec(&interface->o);
    cube_sensors_icm20649_interface_outputs_update(interface);
}

fspec_rv_t cube_sensors_icm20649_call_init_outputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td,
    const char *func_name
)
{
    cube_sensors_icm20649_interface_t *interface = (cube_sensors_icm20649_interface_t*) dh;
    return cube_sensors_icm20649_interface_outputs_init(interface, conn_spec, mounting_td, func_name);
}

void cube_sensors_icm20649_call_exec(void *dh)
{
    cube_sensors_icm20649_interface_t *interface = (cube_sensors_icm20649_interface_t*) dh;
    cube_sensors_icm20649_interface_update(interface);
}

← cube.misc.cli_logger cube.sensors.icm20948 →