Mirrors/VILLASnode
1
0
Fork 0
mirror of https://git.rwth-aachen.de/acs/public/villas/node/ synced 2025-03-16 00:00:02 +01:00
Code Issues Releases Wiki Activity
VILLASnode/lib/mapping.c

446 lines
9.8 KiB
C
Raw Blame History

/** Sample value remapping for mux.
*
* @author Steffen Vogel <stvogel@eonerc.rwth-aachen.de>
* @copyright 2017-2018, Institute for Automation of Complex Power Systems, EONERC
* @license GNU General Public License (version 3)
*
* VILLASnode
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************************/
#include <string.h>
#include <villas/mapping.h>
#include <villas/stats.h>
#include <villas/sample.h>
#include <villas/list.h>
#include <villas/utils.h>
#include <villas/node.h>
#include <villas/signal.h>
int mapping_parse_str(struct mapping_entry *me, const char *str, struct list *nodes)
{
int id;
char *cpy, *node, *type, *field, *subfield, *end;
cpy = strdup(str);
if (!cpy)
return -1;
if (nodes) {
node = strtok(cpy, ".");
if (!node) {
warn("Missing node name");
goto invalid_format;
}
me->node = list_lookup(nodes, node);
if (!me->node) {
warn("Unknown node %s", node);
goto invalid_format;
}
type = strtok(NULL, ".[");
if (!type)
type = "data";
}
else {
me->node = NULL;
type = strtok(cpy, ".[");
if (!type)
goto invalid_format;
}
if (!strcmp(type, "stats")) {
me->type = MAPPING_TYPE_STATS;
me->length = 1;
field = strtok(NULL, ".");
if (!field) {
warn("Missing stats type");
goto invalid_format;
}
subfield = strtok(NULL, ".");
if (!subfield) {
warn("Missing stats sub-type");
goto invalid_format;
}
id = stats_lookup_id(field);
if (id < 0) {
warn("Invalid stats type");
goto invalid_format;
}
me->stats.id = id;
if (!strcmp(subfield, "total"))
me->stats.type = MAPPING_STATS_TYPE_TOTAL;
else if (!strcmp(subfield, "last"))
me->stats.type = MAPPING_STATS_TYPE_LAST;
else if (!strcmp(subfield, "lowest"))
me->stats.type = MAPPING_STATS_TYPE_LOWEST;
else if (!strcmp(subfield, "highest"))
me->stats.type = MAPPING_STATS_TYPE_HIGHEST;
else if (!strcmp(subfield, "mean"))
me->stats.type = MAPPING_STATS_TYPE_MEAN;
else if (!strcmp(subfield, "var"))
me->stats.type = MAPPING_STATS_TYPE_VAR;
else if (!strcmp(subfield, "stddev"))
me->stats.type = MAPPING_STATS_TYPE_STDDEV;
else {
warn("Invalid stats sub-type");
goto invalid_format;
}
}
else if (!strcmp(type, "hdr")) {
me->type = MAPPING_TYPE_HEADER;
me->length = 1;
field = strtok(NULL, ".");
if (!field) {
warn("Missing header type");
goto invalid_format;
}
if (!strcmp(field, "sequence"))
me->header.type = MAPPING_HEADER_TYPE_SEQUENCE;
else if (!strcmp(field, "length"))
me->header.type = MAPPING_HEADER_TYPE_LENGTH;
else {
warn("Invalid header type");
goto invalid_format;
}
}
else if (!strcmp(type, "ts")) {
me->type = MAPPING_TYPE_TIMESTAMP;
me->length = 2;
field = strtok(NULL, ".");
if (!field) {
warn("Missing timestamp type");
goto invalid_format;
}
if (!strcmp(field, "origin"))
me->timestamp.type = MAPPING_TIMESTAMP_TYPE_ORIGIN;
else if (!strcmp(field, "received"))
me->timestamp.type = MAPPING_TIMESTAMP_TYPE_RECEIVED;
else {
warn("Invalid timestamp type");
goto invalid_format;
}
}
else if (!strcmp(type, "data")) {
char *first_str, *last_str;
int first = -1, last = -1;
me->type = MAPPING_TYPE_DATA;
first_str = strtok(NULL, "-]");
if (first_str) {
if (me->node)
first = list_lookup_index(&me->node->signals, first_str);
if (first < 0) {
char *endptr;
first = strtoul(first_str, &endptr, 10);
if (endptr != first_str + strlen(first_str)) {
warn("Failed to parse data range");
goto invalid_format;
}
}
}
else {
/* Map all signals */
me->data.offset = 0;
me->length = me->node ? list_length(&me->node->signals) : 0;
goto end;
}
last_str = strtok(NULL, "]");
if (last_str) {
if (me->node)
last = list_lookup_index(&me->node->signals, last_str);
if (last < 0) {
char *endptr;
last = strtoul(last_str, &endptr, 10);
if (endptr != last_str + strlen(last_str)) {
warn("Failed to parse data range");
goto invalid_format;
}
}
}
else
last = first; /* single element: data[5] => data[5-5] */
if (last < first)
goto invalid_format;
me->data.offset = first;
me->length = last - first + 1;
}
else
goto invalid_format;
end: /* Check that there is no garbage at the end */
end = strtok(NULL, "");
if (end)
goto invalid_format;
free(cpy);
return 0;
invalid_format:
free(cpy);
return -1;
}
int mapping_parse(struct mapping_entry *me, json_t *cfg, struct list *nodes)
{
const char *str;
str = json_string_value(cfg);
if (!str)
return -1;
return mapping_parse_str(me, str, nodes);
}
int mapping_parse_list(struct list *l, json_t *cfg, struct list *nodes)
{
int ret, off;
size_t i;
json_t *json_entry;
json_t *json_mapping;
if (json_is_string(cfg)) {
json_mapping = json_array();
json_array_append(json_mapping, cfg);
}
else if (json_is_array(cfg))
json_mapping = json_incref(cfg);
else
return -1;
off = 0;
json_array_foreach(json_mapping, i, json_entry) {
struct mapping_entry *me = (struct mapping_entry *) alloc(sizeof(struct mapping_entry));
ret = mapping_parse(me, json_entry, nodes);
if (ret)
goto out;
me->offset = off;
off += me->length;
list_push(l, me);
}
ret = 0;
out: json_decref(json_mapping);
return ret;
}
int mapping_update(const struct mapping_entry *me, struct sample *remapped, const struct sample *original, const struct stats *s)
{
int len = me->length;
int off = me->offset;
/* me->length == 0 means that we want to take all values */
if (!len)
len = original->length;
if (len + off > remapped->capacity)
return -1;
switch (me->type) {
case MAPPING_TYPE_STATS: {
const struct hist *h = &s->histograms[me->stats.id];
switch (me->stats.type) {
case MAPPING_STATS_TYPE_TOTAL:
remapped->data[off++].i = h->total;
break;
case MAPPING_STATS_TYPE_LAST:
remapped->data[off++].f = h->last;
break;
case MAPPING_STATS_TYPE_HIGHEST:
remapped->data[off++].f = h->highest;
break;
case MAPPING_STATS_TYPE_LOWEST:
remapped->data[off++].f = h->lowest;
break;
case MAPPING_STATS_TYPE_MEAN:
remapped->data[off++].f = hist_mean(h);
break;
case MAPPING_STATS_TYPE_STDDEV:
remapped->data[off++].f = hist_stddev(h);
break;
case MAPPING_STATS_TYPE_VAR:
remapped->data[off++].f = hist_var(h);
break;
default:
return -1;
}
}
case MAPPING_TYPE_TIMESTAMP: {
const struct timespec *ts;
switch (me->timestamp.type) {
case MAPPING_TIMESTAMP_TYPE_RECEIVED:
ts = &original->ts.received;
break;
case MAPPING_TIMESTAMP_TYPE_ORIGIN:
ts = &original->ts.origin;
break;
default:
return -1;
}
remapped->data[off++].i = ts->tv_sec;
remapped->data[off++].i = ts->tv_nsec;
break;
}
case MAPPING_TYPE_HEADER:
switch (me->header.type) {
case MAPPING_HEADER_TYPE_LENGTH:
remapped->data[off++].i = original->length;
break;
case MAPPING_HEADER_TYPE_SEQUENCE:
remapped->data[off++].i = original->sequence;
break;
default:
return -1;
}
break;
case MAPPING_TYPE_DATA:
for (int j = me->data.offset; j < len + me->data.offset; j++) {
if (j >= original->length)
remapped->data[off++].f = 0;
else
remapped->data[off++] = original->data[j];
}
break;
}
return 0;
}
int mapping_remap(const struct list *m, struct sample *remapped, const struct sample *original, const struct stats *s)
{
int ret;
for (size_t i = 0; i < list_length(m); i++) {
struct mapping_entry *me = (struct mapping_entry *) list_at(m, i);
ret = mapping_update(me, remapped, original, s);
if (ret)
return ret;
}
return 0;
}
int mapping_to_str(const struct mapping_entry *me, unsigned index, char **str)
{
const char *type;
assert(me->length == 0 || index < me->length);
if (me->node)
strcatf(str, "%s.", node_name_short(me->node));
switch (me->type) {
case MAPPING_TYPE_STATS:
switch (me->stats.type) {
case MAPPING_STATS_TYPE_TOTAL:
type = "total";
break;
case MAPPING_STATS_TYPE_LAST:
type = "last";
break;
case MAPPING_STATS_TYPE_LOWEST:
type = "lowest";
break;
case MAPPING_STATS_TYPE_HIGHEST:
type = "highest";
break;
case MAPPING_STATS_TYPE_MEAN:
type = "mean";
break;
case MAPPING_STATS_TYPE_VAR:
type = "var";
break;
case MAPPING_STATS_TYPE_STDDEV:
type = "stddev";
break;
}
strcatf(str, "stats.%s", type);
break;
case MAPPING_TYPE_HEADER:
switch (me->header.type) {
case MAPPING_HEADER_TYPE_LENGTH: type = "length"; break;
case MAPPING_HEADER_TYPE_SEQUENCE: type = "sequence"; break;
}
strcatf(str, "hdr.%s", type);
break;
case MAPPING_TYPE_TIMESTAMP:
switch (me->timestamp.type) {
case MAPPING_TIMESTAMP_TYPE_ORIGIN: type = "origin"; break;
case MAPPING_TIMESTAMP_TYPE_RECEIVED: type = "received"; break;
}
strcatf(str, "ts.%s.%s", type, index == 0 ? "sec" : "nsec");
break;
case MAPPING_TYPE_DATA:
if (me->node && index < list_length(&me->node->signals)) {
struct signal *s = list_at(&me->node->signals, index);
strcatf(str, "data[%s]", s->name);
}
else
strcatf(str, "data[%u]", index);
break;
}
return 0;
}
Reference in a new issue View git blame Copy permalink