static int
constrain_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct drange_constrain_data *mdata = data;
int r;
struct sol_drange value;
r = sol_flow_packet_get_drange(packet, &value);
SOL_INT_CHECK(r, < 0, r);
if (!mdata->use_input_range) {
value.min = mdata->val.min;
value.max = mdata->val.max;
value.step = mdata->val.step;
}
r = _constrain(&value);
SOL_INT_CHECK(r, < 0, r);
mdata->val = value;
return sol_flow_send_drange_packet(node,
SOL_FLOW_NODE_TYPE_FLOAT_CONSTRAIN__OUT__OUT,
&mdata->val);
}
static int
operator_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct drange_arithmetic_data *mdata = data;
struct sol_drange value;
int r;
r = sol_flow_packet_get_drange(packet, &value);
if (r < 0) {
sol_flow_send_error_packet(node, -r, sol_util_strerrora(-r));
return r;
}
if (port == 0) {
mdata->var0 = value;
mdata->var0_initialized = true;
} else {
mdata->var1 = value;
mdata->var1_initialized = true;
}
/* wait until have both variables */
if (!(mdata->var0_initialized && mdata->var1_initialized))
return 0;
r = mdata->func(&mdata->var0, &mdata->var1, &value);
SOL_INT_CHECK(r, < 0, r);
return sol_flow_send_drange_packet(node, mdata->port, &value);
}
static int
map_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct drange_map_data *mdata = data;
struct sol_drange in_value;
double out_value;
int r;
r = sol_flow_packet_get_drange(packet, &in_value);
SOL_INT_CHECK(r, < 0, r);
if (mdata->use_input_range) {
if (isgreaterequal(in_value.min, in_value.max)) {
SOL_WRN("Invalid range: input max must to be bigger than min");
return -EINVAL;
}
r = _map(in_value.val, in_value.min, in_value.max, mdata->output.min,
mdata->output.max, mdata->output_value.step, &out_value);
} else
r = _map(in_value.val, mdata->input.min, mdata->input.max,
mdata->output.min, mdata->output.max, mdata->output_value.step,
&out_value);
SOL_INT_CHECK(r, < 0, r);
mdata->output_value.val = out_value;
return sol_flow_send_drange_packet(node,
SOL_FLOW_NODE_TYPE_FLOAT_MAP__OUT__OUT,
&mdata->output_value);
}
static void
float_receiver(void *data, uint32_t id, struct sol_blob *message)
{
struct sol_flow_node *node = data;
sol_flow_send_drange_packet(node,
SOL_FLOW_NODE_TYPE_IPM_FLOAT_READER__OUT__OUT, message->mem);
sol_blob_unref(message);
}
static int
wave_generator_sinusoidal_process(struct sol_flow_node *node,
void *data,
uint16_t port,
uint16_t conn_id,
const struct sol_flow_packet *packet)
{
struct drange_wave_generator_sinusoidal_data *mdata = data;
sinusoidal_iterate(mdata);
return sol_flow_send_drange_packet
(node, SOL_FLOW_NODE_TYPE_WAVE_GENERATOR_SINUSOIDAL__OUT__OUT,
&mdata->s_state.val);
}
/*
* WARNING: Do NOT use it for anything else than test purposes.
*/
static int
random_float_generate(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct random_node_data *mdata = data;
struct sol_drange out_value = { 0, 0, INT32_MAX, 1 };
int r;
r = sol_random_get_double(mdata->engine, &out_value.val);
if (r < 0)
return r;
return sol_flow_send_drange_packet(node,
SOL_FLOW_NODE_TYPE_RANDOM_FLOAT__OUT__OUT,
&out_value);
}
void
send_float_output(struct gtk_common_data *mdata)
{
double value;
struct sol_drange drange = SOL_DRANGE_INIT();
int r;
extract_value(mdata, &value, 1, "Float");
drange.val = value;
r = sol_flow_send_drange_packet(mdata->node,
SOL_FLOW_NODE_TYPE_GTK_FLOAT_EDITOR__OUT__OUT, &drange);
if (r < 0)
SOL_WRN("Could not send the location packet. Reason: %s",
sol_util_strerrora(-r));
}
static int
constant_drange_open(struct sol_flow_node *node, void *data, const struct sol_flow_node_options *options)
{
const struct sol_flow_node_type_constant_float_options *opts;
struct sol_drange value;
int r;
SOL_FLOW_NODE_OPTIONS_SUB_API_CHECK(options,
SOL_FLOW_NODE_TYPE_CONSTANT_FLOAT_OPTIONS_API_VERSION, -EINVAL);
opts = (const struct sol_flow_node_type_constant_float_options *)options;
r = sol_drange_compose(&opts->value_spec, opts->value, &value);
SOL_INT_CHECK(r, < 0, r);
return sol_flow_send_drange_packet(node,
SOL_FLOW_NODE_TYPE_CONSTANT_FLOAT__OUT__OUT, &value);
}
static int
float_filter_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct sol_drange value;
int r;
struct float_filter_data *mdata = data;
r = sol_flow_packet_get_drange(packet, &value);
SOL_INT_CHECK(r, < 0, r);
if (isgreaterequal(value.val, mdata->min) && islessequal(value.val, mdata->max)) {
if (mdata->range_override) {
value.min = mdata->min;
value.max = mdata->max;
value.step = 1;
}
return sol_flow_send_drange_packet(node, SOL_FLOW_NODE_TYPE_FLOAT_FILTER__OUT__OUT, &value);
}
return 0;
}
static void
send_temperature(struct stts751_data *mdata)
{
double temp;
static const double steps[] = { 0.5, 0.25, 0.125, 0.0625 };
struct sol_drange val = {
.min = -64.0,
.max = 127.9375,
.step = steps[mdata->resolution - 9]
};
SOL_DBG("Temperature registers H:0x%x, L:0x%x", mdata->temp_h, mdata->temp_l);
temp = mdata->temp_h;
/* XXX Check if negative conversion is right */
temp += ((double)(mdata->temp_l) / (1 << 8));
/* To Kelvin */
temp += 273.16;
val.val = temp;
sol_flow_send_drange_packet(mdata->node,
SOL_FLOW_NODE_TYPE_STTS751__OUT__KELVIN, &val);
}
static void
read_cb(void *cb_data, struct sol_i2c *i2c, uint8_t reg,
uint8_t *data, ssize_t status)
{
struct stts751_data *mdata = cb_data;
mdata->i2c_pending = NULL;
if (status < 0) {
const char errmsg[] = "Failed to read STTS751 temperature status";
SOL_WRN(errmsg);
sol_flow_send_error_packet(mdata->node, EIO, errmsg);
mdata->reading_step = READING_NONE;
return;
}
/* If reading status, let's check it */
if (mdata->reading_step == READING_STATUS && mdata->status) {
const char errmsg[] = "Invalid temperature status: 0x%x";
SOL_WRN(errmsg, mdata->status);
mdata->reading_step = READING_NONE;
return;
}
/* Last step, send temperature */
if (mdata->reading_step == READING_TEMP_L) {
send_temperature(mdata);
mdata->reading_step = READING_NONE;
return;
}
mdata->reading_step++;
stts751_read(mdata);
}
static bool
stts751_read(void *data)
{
struct stts751_data *mdata = data;
uint8_t reg, *dst;
mdata->timer = NULL;
if (!set_slave(mdata, stts751_read))
return false;
switch (mdata->reading_step) {
case READING_STATUS:
reg = STATUS_REGISTER;
dst = &mdata->status;
break;
case READING_TEMP_H:
reg = TEMPERATURE_REGISTER_H;
dst = (uint8_t *)&mdata->temp_h;
break;
case READING_TEMP_L:
reg = TEMPERATURE_REGISTER_L;
dst = &mdata->temp_l;
break;
default:
SOL_WRN("Invalid reading step");
return false;
}
mdata->i2c_pending = sol_i2c_read_register(mdata->i2c, reg,
dst, sizeof(*dst), read_cb, mdata);
if (!mdata->i2c_pending) {
const char errmsg[] = "Failed to read STTS751 temperature";
SOL_WRN(errmsg);
sol_flow_send_error_packet(mdata->node, EIO, errmsg);
mdata->reading_step = READING_NONE;
}
return false;
}
static int
temperature_stts751_tick(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct stts751_data *mdata = data;
if (mdata->reading_step != READING_NONE) {
SOL_WRN("Reading operation in progress, discading TICK");
return 0;
}
/* First, read the status, if it's ok, then we read temp high and low */
mdata->reading_step = READING_STATUS;
stts751_read(mdata);
return 0;
}
