emgauwa/controller-legacy
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

add: relay/piface support

Browse source
This commit is contained in:
Tobias Reisinger 2020-04-14 00:50:55 +02:00
parent fa6ceb2bf4
commit db64e4f820
34 changed files with 1259 additions and 313 deletions

60
models/controller.c
View file

@ -7,38 +7,62 @@
#include <models/controller.h>
#include <macros.h>
controller*
controller_t*
controller_create(void)
{
controller *result = malloc(sizeof(*result));
uuid_generate(result->id);
controller_t *new_controller = malloc(sizeof(*new_controller));
uuid_generate(new_controller->id);
strcpy(result->name, "new emgauwa device");
result->command_port = 0;
result->discovery_port = 4421;
result->relay_count = 10;
strcpy(new_controller->name, "new emgauwa device");
new_controller->command_port = 0;
new_controller->discovery_port = 4421;
new_controller->relay_count = 10;
result->relays = malloc(sizeof(*result->relays) * result->relay_count);
new_controller->relays = malloc(sizeof(relay_t) * new_controller->relay_count);
uint8_t i;
for(i = 0; i < result->relay_count; i++)
for(i = 0; i < new_controller->relay_count; ++i)
{
result->relays[i] = relay_init(i);
new_controller->relays[i] = relay_create(i);
}
return result;
return new_controller;
}
void
controller_debug(controller *cntrlr)
controller_set_name(controller_t *controller, char *name)
{
if(cntrlr == NULL)
strncpy(controller->name, name, MAX_NAME_LENGTH);
controller->name[MAX_NAME_LENGTH] = '\0';
}
void
controller_free(controller_t *controller)
{
for(int i = 0; i < controller->relay_count; ++i)
{
relay_free(controller->relays[i]);
}
free(controller->relays);
free(controller);
}
void
controller_debug(controller_t *controller)
{
if(controller == NULL)
{
LOG_DEBUG("controller is NULL");
return;
}
char uuid_str[37];
uuid_unparse(cntrlr->id, uuid_str);
LOG_DEBUG("(1/4) %s @ %p", uuid_str, cntrlr);
LOG_DEBUG("(2/4) name: %s", cntrlr->name);
LOG_DEBUG("(3/4) relays: %3d", cntrlr->relay_count);
LOG_DEBUG("(4/4) command_port: %5d discovery_port: %5d", cntrlr->command_port, cntrlr->discovery_port);
uuid_unparse(controller->id, uuid_str);
LOG_DEBUG("(1/5) %s @ %p", uuid_str, controller);
LOG_DEBUG("(2/5) name: %s", controller->name);
LOG_DEBUG("(3/5) command_port: %5d discovery_port: %5d", controller->command_port, controller->discovery_port);
LOG_DEBUG("(4/5) relay count: %3d", controller->relay_count);
LOG_DEBUG("(5/5) relays @ %p:", controller->relays);
for(uint8_t i = 0; i < controller->relay_count; ++i)
{
relay_debug(controller->relays[i]);
}
}

46
models/controller_load.c
View file

@ -8,73 +8,79 @@
#include <macros.h>
static void
controller_load_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, controller_db_key key_meta, MDB_val *value)
controller_load_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_controller_e key_controller, MDB_val *value)
{
int err;
MDB_val key;
key.mv_size = sizeof(controller_db_key);
key.mv_data = &key_meta;
key.mv_size = sizeof(db_key_controller_e);
key.mv_data = &key_controller;
if((err = mdb_get(mdb_txn, mdb_dbi, &key, value)) != 0)
{
fprintf(stderr, "mdb_get error %s\n", mdb_strerror(err));
LOG_ERROR("mdb_get error %s", mdb_strerror(err));
exit(1);
}
}
controller*
controller_t*
controller_load(MDB_env *mdb_env)
{
int err;
MDB_txn *mdb_txn;
MDB_dbi mdb_dbi;
controller *new_controller;
controller_t *new_controller;
if((err = mdb_txn_begin(mdb_env, NULL, MDB_RDONLY, &mdb_txn)) != 0)
{
fprintf(stderr, "mdb_txn_begin error %s\n", mdb_strerror(err));
LOG_ERROR("mdb_txn_begin error %s", mdb_strerror(err));
return NULL;
}
if((err = mdb_dbi_open(mdb_txn, "meta", 0, &mdb_dbi)) != 0)
if((err = mdb_dbi_open(mdb_txn, "controller", 0, &mdb_dbi)) != 0)
{
switch(err)
{
case MDB_NOTFOUND:
LOG_INFO("no controller found in db. creating new one");
mdb_txn_abort(mdb_txn);
new_controller = controller_create();
new_controller = controller_create();
controller_save(new_controller, mdb_env);
return new_controller;
default:
fprintf(stderr, "mdb_txn_begin error %s\n", mdb_strerror(err));
LOG_ERROR("mdb_txn_begin error %s", mdb_strerror(err));
return NULL;
}
}
new_controller = malloc(sizeof(*new_controller));
new_controller = malloc(sizeof(controller_t));
MDB_val value;
controller_load_single(mdb_txn, mdb_dbi, KEY_META_ID, &value);
controller_load_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_ID, &value);
memmove(new_controller->id, (uuid_t*)value.mv_data, sizeof(uuid_t));
controller_load_single(mdb_txn, mdb_dbi, KEY_META_NAME, &value);
strncpy(new_controller->name, (char*)value.mv_data, CONTROLLER_NAME_LENGTH);
new_controller->name[CONTROLLER_NAME_LENGTH] = '\0';
controller_load_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_NAME, &value);
strncpy(new_controller->name, (char*)value.mv_data, MAX_NAME_LENGTH);
new_controller->name[MAX_NAME_LENGTH] = '\0';
controller_load_single(mdb_txn, mdb_dbi, KEY_META_COMMAND_PORT, &value);
controller_load_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_COMMAND_PORT, &value);
new_controller->command_port = ((uint16_t*)value.mv_data)[0];
controller_load_single(mdb_txn, mdb_dbi, KEY_META_DISCOVERY_PORT, &value);
controller_load_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_DISCOVERY_PORT, &value);
new_controller->discovery_port = ((uint16_t*)value.mv_data)[0];
controller_load_single(mdb_txn, mdb_dbi, KEY_META_RELAY_COUNT, &value);
controller_load_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_RELAY_COUNT, &value);
new_controller->relay_count = ((uint8_t*)value.mv_data)[0];
controller_debug(new_controller);
mdb_txn_abort(mdb_txn); // transaction is read only
new_controller->relays = malloc(sizeof(relay_t*) * new_controller->relay_count);
for(uint8_t i = 0; i < new_controller->relay_count; i++)
{
LOG_TRACE("loading relay %d", i);
new_controller->relays[i] = relay_load(mdb_env, i);
}
return new_controller;
}

59
models/controller_save.c
View file

@ -8,17 +8,17 @@
#include <macros.h>
int
controller_save_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, controller_db_key key_meta, MDB_val value)
controller_save_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_controller_e key_controller, MDB_val value)
{
int err;
MDB_val key;
key.mv_size = sizeof(controller_db_key);
key.mv_data = &key_meta;
key.mv_size = sizeof(db_key_controller_e);
key.mv_data = &key_controller;
if((err = mdb_put(mdb_txn, mdb_dbi, &key, &value, 0)) != 0)
{
fprintf(stderr, "mdb_put error %s\n", mdb_strerror(err));
LOG_ERROR("mdb_put error %s", mdb_strerror(err));
mdb_txn_abort(mdb_txn);
return 1;
}
@ -26,7 +26,7 @@ controller_save_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, controller_db_key key_
}
int
controller_save(controller *cntrlr, MDB_env *mdb_env)
controller_save(controller_t *controller, MDB_env *mdb_env)
{
int err;
@ -34,56 +34,65 @@ controller_save(controller *cntrlr, MDB_env *mdb_env)
MDB_dbi mdb_dbi;
MDB_val value;
controller_debug(cntrlr);
if((err = mdb_txn_begin(mdb_env, NULL, 0, &mdb_txn)) != 0)
{
fprintf(stderr, "mdb_txn_begin error %s\n", mdb_strerror(err));
LOG_ERROR("mdb_txn_begin error %s", mdb_strerror(err));
exit(1);
}
if((err = mdb_dbi_open(mdb_txn, "meta", MDB_CREATE, &mdb_dbi)) != 0)
if((err = mdb_dbi_open(mdb_txn, "controller", MDB_CREATE, &mdb_dbi)) != 0)
{
fprintf(stderr, "mdb_dbi_open error %s\n", mdb_strerror(err));
LOG_ERROR("mdb_dbi_open error %s", mdb_strerror(err));
exit(1);
}
value.mv_size = sizeof(cntrlr->id);
value.mv_data = cntrlr->id;
if(controller_save_single(mdb_txn, mdb_dbi, KEY_META_ID, value))
value.mv_size = sizeof(uuid_t);
value.mv_data = controller->id;
if(controller_save_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_ID, value))
{
LOG_ERROR("failed to save ID");
return 1;
}
value.mv_size = sizeof(char) * (strlen(cntrlr->name) + 1);
value.mv_data = cntrlr->name;
if(controller_save_single(mdb_txn, mdb_dbi, KEY_META_NAME, value))
value.mv_size = sizeof(char) * (strlen(controller->name) + 1);
value.mv_data = controller->name;
if(controller_save_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_NAME, value))
{
LOG_ERROR("failed to save name");
return 1;
}
value.mv_size = sizeof(cntrlr->command_port);
value.mv_data = &cntrlr->command_port;
if(controller_save_single(mdb_txn, mdb_dbi, KEY_META_COMMAND_PORT, value))
value.mv_size = sizeof(controller->command_port);
value.mv_data = &controller->command_port;
if(controller_save_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_COMMAND_PORT, value))
{
LOG_ERROR("failed to save command port");
return 1;
}
value.mv_size = sizeof(cntrlr->discovery_port);
value.mv_data = &cntrlr->discovery_port;
if(controller_save_single(mdb_txn, mdb_dbi, KEY_META_DISCOVERY_PORT, value))
value.mv_size = sizeof(controller->discovery_port);
value.mv_data = &controller->discovery_port;
if(controller_save_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_DISCOVERY_PORT, value))
{
LOG_ERROR("failed to save discovery port");
return 1;
}
value.mv_size = sizeof(cntrlr->relay_count);
value.mv_data = &cntrlr->relay_count;
if(controller_save_single(mdb_txn, mdb_dbi, KEY_META_RELAY_COUNT, value))
value.mv_size = sizeof(controller->relay_count);
value.mv_data = &controller->relay_count;
if(controller_save_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_RELAY_COUNT, value))
{
LOG_ERROR("failed to save relay count");
return 1;
}
mdb_txn_commit(mdb_txn);
for(uint8_t i = 0; i < controller->relay_count; ++i)
{
LOG_TRACE("saving relays[%d/%d]", i, controller->relay_count);
relay_save(controller->relays[i], mdb_env);
}
return 0;
}

44
models/period.c Normal file
View file

@ -0,0 +1,44 @@
#include <stdlib.h>
#include <logger.h>
#include <constants.h>
#include <models/period.h>
period_t*
period_create(uint16_t start, uint16_t end)
{
period_t *new_period = malloc(sizeof(period_t));
new_period->start = start;
new_period->end = end;
return new_period;
}
int
period_includes_time(period_t *period, uint16_t timestamp)
{
uint16_t start = period->start;
uint16_t end = period->end;
// "normal" timespan
if(start < end)
{
if(start <= timestamp && end > timestamp)
{
return 1;
}
return 0;
}
// timespan goes through 00:00
if(end < start)
{
if(start >= timestamp && end < timestamp)
{
return 1;
}
return 0;
}
return 0;
}

81
models/relay.c
View file

@ -1,10 +1,83 @@
#include <stdlib.h>
#include <string.h>
#include <uuid/uuid.h>
#include <constants.h>
#include <logger.h>
#include <models/relay.h>
relay*
relay_init(uint8_t index)
relay_t*
relay_create(uint8_t number)
{
(void)index;
return NULL;
relay_t *new_relay = malloc(sizeof(relay_t));
new_relay->number = number;
new_relay->name[0] = '\0';
uuid_t off_id;
memset(off_id, 0, sizeof(uuid_t));
memcpy(off_id, "off", 3);
new_relay->schedule = schedule_create(off_id, 0, NULL);
return new_relay;
}
void
relay_set_name(relay_t *relay, char *name)
{
strncpy(relay->name, name, MAX_NAME_LENGTH);
relay->name[MAX_NAME_LENGTH] = '\0';
}
int
relay_is_active(relay_t *relay, time_t timestamp_now)
{
if(relay->schedule->length == 0)
{
return 0;
}
// we don't need days. reduce to hours, minutes and seconds
timestamp_now %= SECONDS_PER_DAY;
// finally remove seconds
timestamp_now /= SECONDS_PER_MINUTE;
for(uint16_t i = 0; i < relay->schedule->length; ++i)
{
if(period_includes_time(relay->schedule->periods[i], timestamp_now))
{
return 1;
}
}
return 0;
}
//struct tm time_start, time_now, time_end;
//localtime_r(&timestamp_start, &time_start);
//localtime_r(&timestamp_now, &time_now);
//localtime_r(&timestamp_end, &time_end);
//LOG_DEBUG("%02d:%02d - %02d:%02d - %02d:%02d", time_start.tm_hour, time_start.tm_min, time_now.tm_hour, time_now.tm_min, time_end.tm_hour, time_end.tm_min);
void
relay_debug(relay_t *relay)
{
if(relay == NULL)
{
LOG_DEBUG("relay is NULL");
return;
}
LOG_DEBUG("(1/3) %d @ %p", relay->number, relay);
LOG_DEBUG("(2/3) name: %s", relay->name);
LOG_DEBUG("(3/3) schedule:");
schedule_debug(relay->schedule);
}
void
relay_free(relay_t *relay)
{
if(relay->schedule)
{
schedule_free(relay->schedule);
}
free(relay);
}

100
models/relay_load.c Normal file
View file

@ -0,0 +1,100 @@
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <uuid/uuid.h>
#include <models/relay.h>
#include <macros.h>
static int
relay_load_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_relay_e key_relay, uint8_t num, MDB_val *value)
{
int err;
size_t key_size = sizeof(db_key_relay_e) + sizeof(uint8_t);
void *key_data = malloc(key_size);
memmove(key_data, &key_relay, sizeof(db_key_relay_e));
memmove(key_data + sizeof(db_key_relay_e), &num, sizeof(uint8_t));
MDB_val key;
key.mv_size = key_size;
key.mv_data = key_data;
if((err = mdb_get(mdb_txn, mdb_dbi, &key, value)) != 0)
{
LOG_ERROR("mdb_get error %s", mdb_strerror(err));
mdb_txn_abort(mdb_txn);
free(key_data);
return 1;
}
free(key_data);
return 0;
}
relay_t*
relay_load(MDB_env *mdb_env, uint8_t num)
{
int err;
MDB_txn *mdb_txn;
MDB_dbi mdb_dbi;
relay_t *new_relay;
if((err = mdb_txn_begin(mdb_env, NULL, MDB_RDONLY, &mdb_txn)) != 0)
{
LOG_ERROR("mdb_txn_begin error %s", mdb_strerror(err));
return relay_create(num);
}
if((err = mdb_dbi_open(mdb_txn, "relays", 0, &mdb_dbi)) != 0)
{
switch(err)
{
case MDB_NOTFOUND:
LOG_INFO("no relay for num %d found in db. returning new one (no relays db)", num);
mdb_txn_abort(mdb_txn);
return relay_create(num);
default:
LOG_ERROR("mdb_txn_begin error %s", mdb_strerror(err));
return relay_create(num);
}
}
new_relay = malloc(sizeof(relay_t));
new_relay->number = num;
MDB_val value;
if((err = relay_load_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_NAME, num, &value)) != 0)
{
LOG_INFO("no relay for num %d found in db. returning new one", num);
mdb_txn_abort(mdb_txn); // transaction is read only
return relay_create(num);
}
strncpy(new_relay->name, (char*)value.mv_data, MAX_NAME_LENGTH);
new_relay->name[MAX_NAME_LENGTH] = '\0';
if((err = relay_load_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_SCHEDULE_ID, num, &value)) != 0)
{
LOG_INFO("no relay for num %d found in db. returning new one", num);
mdb_txn_abort(mdb_txn); // transaction is read only
return relay_create(num);
}
uuid_t *schedule_id = (uuid_t*)value.mv_data;
if((err = relay_load_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_SCHEDULE_PERIODS, num, &value)) != 0)
{
LOG_INFO("no relay for num %d found in db. returning new one", num);
mdb_txn_abort(mdb_txn); // transaction is read only
return relay_create(num);
}
uint16_t schedule_periods_length = ((uint16_t*)value.mv_data)[0];
uint16_t *schedule_periods = ((uint16_t*)value.mv_data) + 1;
new_relay->schedule = schedule_create(*schedule_id, schedule_periods_length, schedule_periods);
mdb_txn_abort(mdb_txn); // transaction is read only
return new_relay;
}

88
models/relay_save.c Normal file
View file

@ -0,0 +1,88 @@
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <uuid/uuid.h>
#include <models/relay.h>
#include <macros.h>
static int
relay_save_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_relay_e key_relay, uint8_t num, MDB_val value)
{
int err;
size_t key_size = sizeof(db_key_relay_e) + sizeof(uint8_t);
void *key_data = malloc(key_size);
memmove(key_data, &key_relay, sizeof(db_key_relay_e));
memmove(key_data + sizeof(db_key_relay_e), &num, sizeof(uint8_t));
MDB_val key;
key.mv_size = key_size;
key.mv_data = key_data;
if((err = mdb_put(mdb_txn, mdb_dbi, &key, &value, 0)) != 0)
{
LOG_ERROR("mdb_put error %s", mdb_strerror(err));
mdb_txn_abort(mdb_txn);
free(key_data);
return 1;
}
free(key_data);
return 0;
}
int
relay_save(relay_t *relay, MDB_env *mdb_env)
{
LOG_TRACE("saving relay %d @ %p", relay->number, relay);
int err;
MDB_txn *mdb_txn;
MDB_dbi mdb_dbi;
MDB_val value;
if((err = mdb_txn_begin(mdb_env, NULL, 0, &mdb_txn)) != 0)
{
LOG_ERROR("mdb_txn_begin error %s", mdb_strerror(err));
exit(1);
}
if((err = mdb_dbi_open(mdb_txn, "relays", MDB_CREATE, &mdb_dbi)) != 0)
{
LOG_ERROR("mdb_dbi_open error %s", mdb_strerror(err));
exit(1);
}
value.mv_size = sizeof(char) * (strlen(relay->name) + 1);
value.mv_data = relay->name;
if(relay_save_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_NAME, relay->number, value))
{
LOG_ERROR("failed to save name");
return 1;
}
value.mv_size = sizeof(uuid_t);
value.mv_data = relay->schedule->id;
if(relay_save_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_SCHEDULE_ID, relay->number, value))
{
LOG_ERROR("failed to save ID");
return 1;
}
// save periods blob
uint16_t *periods_blob = schedule_periods_to_blob(relay->schedule);
value.mv_size = sizeof(uint16_t) * ((periods_blob[0] * 2) + 1);
value.mv_data = periods_blob;
if(relay_save_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_SCHEDULE_PERIODS, relay->number, value))
{
free(periods_blob);
LOG_ERROR("failed to save periods");
return 1;
}
free(periods_blob);
mdb_txn_commit(mdb_txn);
return 0;
}

89
models/schedule.c Normal file
View file

@ -0,0 +1,89 @@
#include <stdlib.h>
#include <string.h>
#include <logger.h>
#include <models/schedule.h>
schedule_t*
schedule_create(uuid_t id, uint16_t length, uint16_t *periods_blob)
{
schedule_t *new_schedule = malloc(sizeof(schedule_t));
memmove(new_schedule->id, id, sizeof(uuid_t));
new_schedule->length = length;
new_schedule->periods = NULL;
if(length)
{
new_schedule->periods = malloc(sizeof(period_t*) * length);
for(uint16_t i = 0; i < length; ++i)
{
uint16_t start = periods_blob[0 + (i * 2)];
uint16_t end = periods_blob[1 + (i * 2)];
new_schedule->periods[i] = period_create(start, end);
}
}
return new_schedule;
}
uint16_t*
schedule_periods_to_blob(schedule_t *schedule)
{
uint16_t *periods_blob = malloc(sizeof(uint16_t) * ((2 * schedule->length) + 1));
periods_blob[0] = schedule->length;
for(uint16_t i = 0; i < schedule->length; ++i)
{
periods_blob[1 + (i * 2)] = schedule->periods[i]->start;
periods_blob[2 + (i * 2)] = schedule->periods[i]->end;
}
return periods_blob;
}
void
schedule_free(schedule_t *schedule)
{
for(uint16_t i = 0; i < schedule->length; ++i)
{
free(schedule->periods[i]);
}
free(schedule->periods);
free(schedule);
}
void
schedule_debug(schedule_t *schedule)
{
if(schedule == NULL)
{
LOG_DEBUG("schedule is NULL");
return;
}
char uuid_str[37];
uuid_unparse(schedule->id, uuid_str);
LOG_DEBUG("(1/3) %s @ %p", uuid_str, schedule);
LOG_DEBUG("(2/3) period count: %3d", schedule->length);
// one block: "HH:MM-HH:MM, " --> size: 13 (14 with '\0')
char *periods_debug_str = malloc(sizeof(char) * ((schedule->length * 13) + 1));
periods_debug_str[0] = '\0';
for(uint16_t i = 0; i < schedule->length; ++i)
{
sprintf(
periods_debug_str + (13 * i),
"%02d:%02d-%02d:%02d, ",
schedule->periods[i]->start / 60,
schedule->periods[i]->start % 60,
schedule->periods[i]->end / 60,
schedule->periods[i]->end % 60
);
}
LOG_DEBUG("(3/3) periods: %s", periods_debug_str);
}