2020-07-04 18:16:03 +02:00
|
|
|
/** Signal metadata list.
|
|
|
|
*
|
|
|
|
* @author Steffen Vogel <stvogel@eonerc.rwth-aachen.de>
|
|
|
|
* @copyright 2014-2020, 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 <villas/signal.h>
|
|
|
|
#include <villas/signal_type.h>
|
|
|
|
#include <villas/signal_data.h>
|
|
|
|
#include <villas/signal_list.h>
|
|
|
|
#include <villas/list.h>
|
|
|
|
#include <villas/utils.hpp>
|
|
|
|
#include <villas/exceptions.hpp>
|
|
|
|
|
|
|
|
using namespace villas;
|
|
|
|
using namespace villas::utils;
|
|
|
|
|
|
|
|
int signal_list_init(struct vlist *list)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = vlist_init(list);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-10-21 20:57:03 +02:00
|
|
|
int signal_list_clear(struct vlist *list)
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < vlist_length(list); i++) {
|
|
|
|
struct signal *sig = (struct signal *) vlist_at(list, i);
|
|
|
|
|
|
|
|
signal_decref(sig);
|
|
|
|
}
|
|
|
|
|
|
|
|
vlist_clear(list);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-07-04 18:16:03 +02:00
|
|
|
int signal_list_destroy(struct vlist *list)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = vlist_destroy(list, (dtor_cb_t) signal_decref, false);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-02-16 14:15:14 +01:00
|
|
|
int signal_list_parse(struct vlist *list, json_t *json)
|
2020-07-04 18:16:03 +02:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct signal *s;
|
|
|
|
|
2021-02-16 14:15:14 +01:00
|
|
|
if (!json_is_array(json))
|
2020-07-04 18:16:03 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
size_t i;
|
|
|
|
json_t *json_signal;
|
2021-02-16 14:15:14 +01:00
|
|
|
json_array_foreach(json, i, json_signal) {
|
2020-07-04 18:16:03 +02:00
|
|
|
s = new struct signal;
|
|
|
|
if (!s)
|
|
|
|
throw MemoryAllocationError();
|
|
|
|
|
|
|
|
ret = signal_init(s);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = signal_parse(s, json_signal);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
vlist_push(list, s);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int signal_list_generate(struct vlist *list, unsigned len, enum SignalType typ)
|
|
|
|
{
|
|
|
|
char name[32];
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < len; i++) {
|
2020-09-11 14:57:05 +02:00
|
|
|
snprintf(name, sizeof(name), "signal%u", i);
|
2020-07-04 18:16:03 +02:00
|
|
|
|
|
|
|
struct signal *sig = signal_create(name, nullptr, typ);
|
|
|
|
if (!sig)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
vlist_push(list, sig);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int signal_list_generate2(struct vlist *list, const char *dt)
|
|
|
|
{
|
|
|
|
int len, i = 0;
|
|
|
|
char name[32], *e;
|
|
|
|
enum SignalType typ;
|
|
|
|
|
|
|
|
for (const char *t = dt; *t; t = e + 1) {
|
|
|
|
len = strtoul(t, &e, 10);
|
|
|
|
if (t == e)
|
|
|
|
len = 1;
|
|
|
|
|
|
|
|
typ = signal_type_from_fmtstr(*e);
|
|
|
|
if (typ == SignalType::INVALID)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (int j = 0; j < len; j++) {
|
|
|
|
snprintf(name, sizeof(name), "signal%d", i++);
|
|
|
|
|
|
|
|
struct signal *sig = signal_create(name, nullptr, typ);
|
|
|
|
if (!sig)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
vlist_push(list, sig);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-07-06 18:31:19 +02:00
|
|
|
/** Check if two signal names are numbered ascendingly
|
|
|
|
*
|
|
|
|
* E.g. signal3 -> signal4
|
|
|
|
*/
|
|
|
|
static
|
|
|
|
bool signal_name_is_next(const char *a, const char *b)
|
2020-07-04 18:16:03 +02:00
|
|
|
{
|
2021-07-06 18:31:19 +02:00
|
|
|
unsigned i;
|
|
|
|
unsigned long na, nb;
|
|
|
|
char *ea, *eb;
|
|
|
|
|
|
|
|
/* Find common prefix */
|
|
|
|
for (i = 0; a[i] && b[i] && a[i] == b[i]; i++);
|
|
|
|
|
|
|
|
na = strtoul(a + i, &ea, 10);
|
|
|
|
nb = strtoul(b + i, &eb, 10);
|
|
|
|
|
|
|
|
return !*ea && !*eb && na + 1 == nb;
|
|
|
|
}
|
2020-07-04 18:16:03 +02:00
|
|
|
|
2021-07-06 18:31:19 +02:00
|
|
|
static
|
|
|
|
bool signal_is_next(const struct signal *a, const struct signal *b)
|
|
|
|
{
|
|
|
|
if (a->type != b->type)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (a->unit && b->unit && strcmp(a->unit, b->unit))
|
|
|
|
return false;
|
2020-07-04 18:16:03 +02:00
|
|
|
|
2021-07-06 18:31:19 +02:00
|
|
|
return signal_name_is_next(a->name, b->name);
|
|
|
|
}
|
2020-07-04 18:16:03 +02:00
|
|
|
|
2021-07-06 18:31:19 +02:00
|
|
|
void signal_list_dump(Logger logger, const struct vlist *list, const union signal_data *data, unsigned len)
|
|
|
|
{
|
|
|
|
const char *pfx;
|
|
|
|
bool abbrev = false;
|
2020-07-04 18:16:03 +02:00
|
|
|
|
2021-07-06 18:31:19 +02:00
|
|
|
for (size_t i = 0; i < vlist_length(list); i++) {
|
|
|
|
struct signal *sig = (struct signal *) vlist_at(list, i);
|
2020-07-04 18:16:03 +02:00
|
|
|
|
2021-07-06 18:31:19 +02:00
|
|
|
/* Check if this is a sequence of similar signals which can be abbreviated */
|
|
|
|
if (i >= 1 && i < vlist_length(list) - 1) {
|
|
|
|
struct signal *prevSig = (struct signal *) vlist_at(list, i - 1);
|
2020-07-04 18:16:03 +02:00
|
|
|
|
2021-07-06 18:31:19 +02:00
|
|
|
if (signal_is_next(prevSig, sig)) {
|
|
|
|
abbrev = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2020-07-04 18:16:03 +02:00
|
|
|
|
2021-07-06 18:31:19 +02:00
|
|
|
if (abbrev) {
|
|
|
|
pfx = "...";
|
|
|
|
abbrev = false;
|
2020-07-04 18:16:03 +02:00
|
|
|
}
|
2021-07-06 18:31:19 +02:00
|
|
|
else
|
|
|
|
pfx = " ";
|
2020-07-04 18:16:03 +02:00
|
|
|
|
2021-07-06 18:31:19 +02:00
|
|
|
char *buf = signal_print(sig, i < len ? &data[i] : nullptr);
|
|
|
|
logger->debug(" {}{:>3}: {}", pfx, i, buf);
|
2020-07-04 18:16:03 +02:00
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int signal_list_copy(struct vlist *dst, const struct vlist *src)
|
|
|
|
{
|
|
|
|
assert(src->state == State::INITIALIZED);
|
|
|
|
assert(dst->state == State::INITIALIZED);
|
|
|
|
|
|
|
|
for (size_t i = 0; i < vlist_length(src); i++) {
|
|
|
|
struct signal *sig = (struct signal *) vlist_at_safe(src, i);
|
|
|
|
|
|
|
|
signal_incref(sig);
|
|
|
|
|
|
|
|
vlist_push(dst, sig);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
json_t * signal_list_to_json(struct vlist *list)
|
|
|
|
{
|
|
|
|
json_t *json_signals = json_array();
|
|
|
|
|
|
|
|
for (size_t i = 0; i < vlist_length(list); i++) {
|
|
|
|
struct signal *sig = (struct signal *) vlist_at_safe(list, i);
|
|
|
|
|
2020-07-04 22:01:24 +02:00
|
|
|
json_t *json_signal = json_pack("{ s: s, s: b }",
|
2020-07-04 18:16:03 +02:00
|
|
|
"type", signal_type_to_str(sig->type),
|
2020-07-04 22:01:24 +02:00
|
|
|
"enabled", sig->enabled
|
2020-07-04 18:16:03 +02:00
|
|
|
);
|
|
|
|
|
2020-07-04 22:01:24 +02:00
|
|
|
if (sig->name)
|
|
|
|
json_object_set_new(json_signal, "name", json_string(sig->name));
|
|
|
|
|
|
|
|
if (sig->unit)
|
|
|
|
json_object_set_new(json_signal, "unit", json_string(sig->unit));
|
|
|
|
|
|
|
|
if (!sig->init.is_nan())
|
2021-02-19 06:37:21 +01:00
|
|
|
json_object_set_new(json_signal, "init", signal_data_to_json(&sig->init, sig->type));
|
2020-07-04 22:01:24 +02:00
|
|
|
|
2020-07-04 18:16:03 +02:00
|
|
|
json_array_append_new(json_signals, json_signal);
|
|
|
|
}
|
|
|
|
|
|
|
|
return json_signals;
|
|
|
|
}
|