From c2ee02ce28a7c7a9bebe9b69f214e8e441d60cc8 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Sat, 25 Feb 2017 16:18:26 -0500
Subject: specify types

---
 src/survive_config.c | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index ed3f6cd..09153fa 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -1,3 +1,5 @@
+// (C) 2017 <>< Joshua Allen, Under MIT/x11 License.
+
 #include <string.h>
 #include <assert.h>
 #include "survive_config.h"
@@ -14,6 +16,7 @@ void config_init() {
 	for (i=0;i<MAX_CONFIG_ENTRIES;++i) {
 		config_values[i].str = NULL;
 		config_values[i].tag = NULL;
+		config_values[i].type = CONFIG_UNKNOWN;
 	}
 
 	used_entries = 0;
@@ -83,6 +86,7 @@ const char* config_read_str(const char *tag, const char *value, const char *def_
 	i = used_entries++;
 	sstrcpy(config_values[i].tag, tag);
 	sstrcpy(config_values[i].str, def_str);
+	config_values[i].type = CONFIG_STRING;
 
 	return config_values[i].str;
 }
@@ -99,6 +103,7 @@ uint32_t config_read_uint32(const char *tag, const uint32_t value, const uint32_
 	i = used_entries++;
 	sstrcpy(config_values[i].tag, tag);
 	config_values[i].numeric.i = def;
+	config_values[i].type = CONFIG_UINT32;
 
 	return config_values[i].numeric.i;
 }
@@ -115,6 +120,7 @@ FLT config_read_float(const char *tag, const FLT value, const FLT def) {
 	i = used_entries++;
 	sstrcpy(config_values[i].tag, tag);
 	config_values[i].numeric.f = def;
+	config_values[i].type = CONFIG_FLOAT;
 
 	return config_values[i].numeric.f;
 }
@@ -127,6 +133,7 @@ const char* config_set_str(const char *tag, const char* value) {
 	i = used_entries++;
 	sstrcpy(config_values[i].tag, tag);
 	sstrcpy(config_values[i].str, value);
+	config_values[i].type = CONFIG_STRING;
 
 	return value;
 }
@@ -139,6 +146,7 @@ const uint32_t config_set_uint32(const char *tag, const uint32_t value) {
 	i = used_entries++;
 	sstrcpy(config_values[i].tag, tag);
 	config_values[i].numeric.i = value;
+	config_values[i].type = CONFIG_UINT32;
 
 	return value;
 }
@@ -151,6 +159,7 @@ const FLT config_set_float(const char *tag, const FLT value) {
 	i = used_entries++;
 	sstrcpy(config_values[i].tag, tag);
 	config_values[i].numeric.f = value;
+	config_values[i].type = CONFIG_FLOAT;
 
 	return value;
 }
-- 
cgit v1.2.3


From 373ea323ce2d37b45d438cbe7299365b32240f04 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Sat, 25 Feb 2017 23:53:33 -0500
Subject: some progress on json file writing

---
 src/survive_config.c | 214 +++++++++++++++++++++++++++++++++++----------------
 1 file changed, 149 insertions(+), 65 deletions(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index 09153fa..b18f083 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -10,13 +10,15 @@ config_val config_values[MAX_CONFIG_ENTRIES];
 static uint16_t used_entries = 0;
 
 static FILE *config_file = NULL;
+const FLT* config_set_float_a(const char *tag, const FLT* values, uint8_t count);
 
 void config_init() {
 	uint16_t i = 0;
 	for (i=0;i<MAX_CONFIG_ENTRIES;++i) {
-		config_values[i].str = NULL;
+		config_values[i].data = NULL;
 		config_values[i].tag = NULL;
 		config_values[i].type = CONFIG_UNKNOWN;
+		config_values[i].elements = 0;
 	}
 
 	used_entries = 0;
@@ -26,18 +28,41 @@ void write_float(char* tag, FLT x) {
 	fprintf(config_file, "\"%s\":\"%f\"\n", tag, x);
 }
 
-void write_float_a(char* tag, FLT *x, uint8_t count) {
+void set_float_a(char* tag, FLT *x, uint8_t count) {
 	uint8_t i = 0;
-	char idx[4];
+	char t[100];
+		printf("set float\n",t,x[i]);
 	for (i=0;i<count;++i) {
-		sprintf(idx,"%d",i);
-		fprintf(config_file, "\"%s%s\":\"%f\"\n", tag,idx, x);
+		sprintf(t,"%s%d",tag,i);
+		printf("%s:%f\n",t,x[i]);
+		config_set_float(t,x[i]);
+	}
+}
+/*
+void set_float_a2(char* tag, char **x, uint8_t count) {
+	uint8_t i = 0;
+	char t[100];
+
+	if (*x == NULL) {
+		*x = (float*)malloc(count*sizeof(float));
+	} else {
+		*x = (float*)realloc(*x, count);
+	}
+
+	memcpy(x,)
+	strcpy(*x,src);
+
+
+	for (i=0;i<count;++i) {
+		sprintf(t,"%s%d",tag,i);
+		printf("%s:%f\n",t,x[i]);
+		config_set_float(t,x[i]);
 	}
-	fprintf(config_file, "\"%s\":\"%f\"\n", tag, x);
 }
+*/
+void set_uint32(char* tag, uint32_t x) {
+//	fprintf(config_file, "\"%s\":\"%d\"\n", tag, x);
 
-void write_uint32(char* tag, uint32_t x) {
-	fprintf(config_file, "\"%s\":\"%d\"\n", tag, x);
 }
 
 void config_open(const char* path, const char* mode) {
@@ -47,7 +72,7 @@ void config_open(const char* path, const char* mode) {
 void config_close() {
 	fclose(config_file);
 }
-
+/*
 void config_write_lighthouse(struct BaseStationData* bsd, uint8_t length) {
 	uint8_t i = 0;
 
@@ -63,106 +88,163 @@ void config_write_lighthouse(struct BaseStationData* bsd, uint8_t length) {
 		write_float_a("fcalgibmag", bsd[i].fcalgibmag,2);
 	}
 }
+*/
+void config_set_lighthouse(struct BaseStationData* bsd, uint8_t idx) {
+	config_set_uint32("index", idx);
+	config_set_uint32("id", bsd->BaseStationID);
+	config_set_float_a("position", bsd->Position, 3);
+	config_set_float_a("quaternion", bsd->Quaternion, 4);
+	config_set_float_a("fcalphase", bsd->fcalphase, 2);
+	config_set_float_a("fcaltilt", bsd->fcaltilt,2);
+	config_set_float_a("fcalcurve", bsd->fcalcurve,2);
+	config_set_float_a("fcalgibpha", bsd->fcalgibpha,2);
+	config_set_float_a("fcalgibmag", bsd->fcalgibmag,2);
+}
 
-void sstrcpy(char* dest, const char *src) {
+void sstrcpy(char** dest, const char *src) {
 	uint32_t len = strlen(src)+1;
-	if (dest == NULL) {
-		dest = (char*)malloc(len);
+	if (*dest == NULL) {
+		*dest = (char*)malloc(len);
 	} else {
-		dest = (char*)realloc(dest, len);
+		*dest = (char*)realloc(*dest, len);
 	}
-	strcpy(dest,src);
+	strcpy(*dest,src);
 }
 
-const char* config_read_str(const char *tag, const char *value, const char *def_str) {
+config_val* find_config_entry(const char *tag) {
 	uint16_t i = 0;
 	for (i=0;i<used_entries;++i) {
 		if ( strcmp(config_values[i].tag, tag) == 0 ) {
-			return config_values[i].str;
+			return config_values+i;
 		}
 	}
+	return NULL;
+}
+
+const char* config_read_str(const char *tag, const char *value, const char *def_str) {
+	config_val *cv = find_config_entry(tag);
+
+	if (cv != NULL) return cv->data;
+
 	assert(used_entries<MAX_CONFIG_ENTRIES);
 
-	i = used_entries++;
-	sstrcpy(config_values[i].tag, tag);
-	sstrcpy(config_values[i].str, def_str);
-	config_values[i].type = CONFIG_STRING;
+	used_entries++;
+	sstrcpy(&(cv->tag), tag);
+	sstrcpy(&(cv->data), def_str);
+	cv->type = CONFIG_STRING;
 
-	return config_values[i].str;
+	return cv->data;
 }
 
 uint32_t config_read_uint32(const char *tag, const uint32_t value, const uint32_t def) {
-	uint16_t i = 0;
-	for (i=0;i<used_entries;++i) {
-		if ( strcmp(config_values[i].tag, tag) == 0 ) {
-			return config_values[i].numeric.i;
-		}
-	}
+	config_val *cv = find_config_entry(tag);
+
+	if (cv != NULL) return cv->numeric.i;
+
 	assert(used_entries<MAX_CONFIG_ENTRIES);
 
-	i = used_entries++;
-	sstrcpy(config_values[i].tag, tag);
-	config_values[i].numeric.i = def;
-	config_values[i].type = CONFIG_UINT32;
+	used_entries++;
+	sstrcpy(&(cv->tag), tag);
+	cv->numeric.i = def;
+	cv->type = CONFIG_UINT32;
 
-	return config_values[i].numeric.i;
+	return cv->numeric.i;
 }
 
 FLT config_read_float(const char *tag, const FLT value, const FLT def) {
-	uint16_t i = 0;
-	for (i=0;i<used_entries;++i) {
-		if ( strcmp(config_values[i].tag, tag) == 0 ) {
-			return config_values[i].numeric.f;
-		}
-	}
+	config_val *cv = find_config_entry(tag);
+
+	if (cv != NULL) return cv->numeric.f;
+
 	assert(used_entries<MAX_CONFIG_ENTRIES);
 
-	i = used_entries++;
-	sstrcpy(config_values[i].tag, tag);
-	config_values[i].numeric.f = def;
-	config_values[i].type = CONFIG_FLOAT;
+	used_entries++;
+	sstrcpy(&(cv->tag), tag);
+	cv->numeric.f = def;
+	cv->type = CONFIG_FLOAT;
 
-	return config_values[i].numeric.f;
+	return cv->numeric.f;
 }
 
-const char* config_set_str(const char *tag, const char* value) {
-	uint16_t i = 0;
-
+config_val* next_unused_val() {
+	config_val *cv = config_values+used_entries;
 	assert(used_entries<MAX_CONFIG_ENTRIES);
+	used_entries++;
+	return cv;
+}
+
+const char* config_set_str(const char *tag, const char* value) {
+	config_val *cv = find_config_entry(tag);
+	if (cv == NULL) cv = next_unused_val();
 
-	i = used_entries++;
-	sstrcpy(config_values[i].tag, tag);
-	sstrcpy(config_values[i].str, value);
-	config_values[i].type = CONFIG_STRING;
+	sstrcpy(&(cv->tag), tag);
+	sstrcpy(&(cv->data), value);
+	cv->type = CONFIG_STRING;
 
 	return value;
 }
 
 const uint32_t config_set_uint32(const char *tag, const uint32_t value) {
-	uint16_t i = 0;
-
-	assert(used_entries<MAX_CONFIG_ENTRIES);
+	config_val *cv = find_config_entry(tag);
+	if (cv == NULL) cv = next_unused_val();
 
-	i = used_entries++;
-	sstrcpy(config_values[i].tag, tag);
-	config_values[i].numeric.i = value;
-	config_values[i].type = CONFIG_UINT32;
+	sstrcpy(&(cv->tag), tag);
+	cv->numeric.i = value;
+	cv->type = CONFIG_UINT32;
 
 	return value;
 }
 
 const FLT config_set_float(const char *tag, const FLT value) {
-	uint16_t i = 0;
+	config_val *cv = find_config_entry(tag);
+	if (cv == NULL) cv = next_unused_val();
 
-	assert(used_entries<MAX_CONFIG_ENTRIES);
-
-	i = used_entries++;
-	sstrcpy(config_values[i].tag, tag);
-	config_values[i].numeric.f = value;
-	config_values[i].type = CONFIG_FLOAT;
+	sstrcpy(&(cv->tag), tag);
+	cv->numeric.f = value;
+	cv->type = CONFIG_FLOAT;
 
 	return value;
 }
+
+const FLT* config_set_float_a(const char *tag, const FLT* values, uint8_t count) {
+	config_val *cv = find_config_entry(tag);
+	if (cv == NULL) cv = next_unused_val();
+
+	sstrcpy(&(cv->tag), tag);
+
+	if (cv->data == NULL) {
+		cv->data = (char*)malloc(sizeof(FLT)*count);
+	}
+	else {
+		cv->data = (char*)realloc(cv->data, sizeof(FLT)*count);
+	}
+	printf("float array\n");
+
+	memcpy(cv->data,values,sizeof(FLT)*count);
+	cv->type = CONFIG_FLOAT_ARRAY;
+	cv->elements = count;
+
+	return values;
+}
+
+void write_float_array(FILE* f, char* tag, FLT* v, uint8_t count) {
+	uint8_t i = 0;
+		printf("save float array\n");
+
+	fprintf(f, "\"%s\":[", tag);
+	for (i=0;i<count;++i) {
+//		if (i>0) {
+			fprintf(f, "\"%f\",", v[i]);
+//		} else {
+//			fprintf(f, "\"%f\"", v[i]);
+//		}
+	}
+
+	fseek(f,-1,SEEK_CUR);
+	fprintf(f, "]\n");
+
+}
+
 void config_save(const char* path) {
 	uint16_t i = 0;
 
@@ -174,7 +256,9 @@ void config_save(const char* path) {
 		} else if (config_values[i].type == CONFIG_UINT32) {
 			fprintf(f, "\"%s\":\"%d\"\n", config_values[i].tag, config_values[i].numeric.i);
 		} else if (config_values[i].type == CONFIG_STRING) {
-			fprintf(f, "\"%s\":\"%s\"\n", config_values[i].tag, config_values[i].str);
+			fprintf(f, "\"%s\":\"%s\"\n", config_values[i].tag, config_values[i].data);
+		} else if (config_values[i].type == CONFIG_FLOAT_ARRAY) {
+			write_float_array(f, config_values[i].tag, (FLT*)config_values[i].data, config_values[i].elements);
 		}
 	};
 
-- 
cgit v1.2.3


From f78983a584768a54503535be0366b07c97738299 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Sun, 26 Feb 2017 10:20:48 -0500
Subject: use json helpers

---
 src/survive_config.c | 28 +++++++---------------------
 1 file changed, 7 insertions(+), 21 deletions(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index b18f083..6afe3d1 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -1,8 +1,8 @@
 // (C) 2017 <>< Joshua Allen, Under MIT/x11 License.
-
 #include <string.h>
 #include <assert.h>
 #include "survive_config.h"
+#include <json_helpers.h>
 
 #define MAX_CONFIG_ENTRIES 100
 
@@ -227,22 +227,8 @@ const FLT* config_set_float_a(const char *tag, const FLT* values, uint8_t count)
 	return values;
 }
 
-void write_float_array(FILE* f, char* tag, FLT* v, uint8_t count) {
-	uint8_t i = 0;
-		printf("save float array\n");
-
-	fprintf(f, "\"%s\":[", tag);
-	for (i=0;i<count;++i) {
-//		if (i>0) {
-			fprintf(f, "\"%f\",", v[i]);
-//		} else {
-//			fprintf(f, "\"%f\"", v[i]);
-//		}
-	}
-
-	fseek(f,-1,SEEK_CUR);
-	fprintf(f, "]\n");
-
+void _json_write_float_array(FILE* f, const char* tag, FLT* v, uint8_t count) {
+	json_write_double_array(f,tag,v,count);
 }
 
 void config_save(const char* path) {
@@ -252,13 +238,13 @@ void config_save(const char* path) {
 
 	for (i=0;i<=used_entries;++i) {
 		if (config_values[i].type == CONFIG_FLOAT) {
-			fprintf(f, "\"%s\":\"%F\"\n", config_values[i].tag, config_values[i].numeric.f);
+			json_write_float(f, config_values[i].tag, config_values[i].numeric.f);
 		} else if (config_values[i].type == CONFIG_UINT32) {
-			fprintf(f, "\"%s\":\"%d\"\n", config_values[i].tag, config_values[i].numeric.i);
+			json_write_uint32(f, config_values[i].tag, config_values[i].numeric.i);
 		} else if (config_values[i].type == CONFIG_STRING) {
-			fprintf(f, "\"%s\":\"%s\"\n", config_values[i].tag, config_values[i].data);
+			json_write_str(f, config_values[i].tag, config_values[i].data);
 		} else if (config_values[i].type == CONFIG_FLOAT_ARRAY) {
-			write_float_array(f, config_values[i].tag, (FLT*)config_values[i].data, config_values[i].elements);
+			_json_write_float_array(f, config_values[i].tag, (FLT*)config_values[i].data, config_values[i].elements);
 		}
 	};
 
-- 
cgit v1.2.3


From e8d696e03128242be33eb0734addee645e894635 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Mon, 27 Feb 2017 20:52:26 -0500
Subject: basic config can be written to file

---
 src/survive_config.c | 230 +++++++++++++++++++++------------------------------
 1 file changed, 94 insertions(+), 136 deletions(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index 6afe3d1..dfbd0e2 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -5,104 +5,65 @@
 #include <json_helpers.h>
 
 #define MAX_CONFIG_ENTRIES 100
+#define MAX_LIGHTHOUSES 2
 
-config_val config_values[MAX_CONFIG_ENTRIES];
-static uint16_t used_entries = 0;
 
-static FILE *config_file = NULL;
-const FLT* config_set_float_a(const char *tag, const FLT* values, uint8_t count);
-
-void config_init() {
-	uint16_t i = 0;
-	for (i=0;i<MAX_CONFIG_ENTRIES;++i) {
-		config_values[i].data = NULL;
-		config_values[i].tag = NULL;
-		config_values[i].type = CONFIG_UNKNOWN;
-		config_values[i].elements = 0;
-	}
-
-	used_entries = 0;
-}
-
-void write_float(char* tag, FLT x) {
-	fprintf(config_file, "\"%s\":\"%f\"\n", tag, x);
-}
 
-void set_float_a(char* tag, FLT *x, uint8_t count) {
-	uint8_t i = 0;
-	char t[100];
-		printf("set float\n",t,x[i]);
-	for (i=0;i<count;++i) {
-		sprintf(t,"%s%d",tag,i);
-		printf("%s:%f\n",t,x[i]);
-		config_set_float(t,x[i]);
-	}
-}
-/*
-void set_float_a2(char* tag, char **x, uint8_t count) {
-	uint8_t i = 0;
-	char t[100];
+config_group global_config_values;
+config_group lh_config[MAX_LIGHTHOUSES]; //lighthouse configs
 
-	if (*x == NULL) {
-		*x = (float*)malloc(count*sizeof(float));
-	} else {
-		*x = (float*)realloc(*x, count);
-	}
+//static uint16_t used_entries = 0;
 
-	memcpy(x,)
-	strcpy(*x,src);
+static FILE *config_file = NULL;
+const FLT* config_set_float_a(config_group *cg, const char *tag, const FLT* values, uint8_t count);
 
+void init_config_group(config_group *cg, uint16_t count) {
+	uint16_t i = 0;
+	cg->config_entries = malloc(count*sizeof(config_entry));
+	cg->used_entries = 0;
+	cg->max_entries = count;
 
 	for (i=0;i<count;++i) {
-		sprintf(t,"%s%d",tag,i);
-		printf("%s:%f\n",t,x[i]);
-		config_set_float(t,x[i]);
+		cg->config_entries[i].data = NULL;
+		cg->config_entries[i].tag = NULL;
+		cg->config_entries[i].type = CONFIG_UNKNOWN;
+		cg->config_entries[i].elements = 0;
 	}
 }
-*/
-void set_uint32(char* tag, uint32_t x) {
-//	fprintf(config_file, "\"%s\":\"%d\"\n", tag, x);
 
+void config_init() {
+	uint16_t i = 0;
+	init_config_group(&global_config_values, MAX_CONFIG_ENTRIES);
+	for(i=0;i<MAX_LIGHTHOUSES;i++) {
+		init_config_group(lh_config+i, 9);
+	}
 }
 
-void config_open(const char* path, const char* mode) {
-	config_file = fopen(path, mode);
+void config_load(const char* path) {
+	config_file = fopen(path, "r");
 }
 
 void config_close() {
 	fclose(config_file);
 }
-/*
-void config_write_lighthouse(struct BaseStationData* bsd, uint8_t length) {
-	uint8_t i = 0;
-
-	for (i=0;i<length; ++i) {
-		write_uint32("id", bsd[i].BaseStationID);
-		write_float_a("position", bsd[i].Position, 3);
-		write_float_a("quaternion", bsd[i].Quaternion, 4);
-		write_float_a("quaternion", bsd[i].Quaternion, 4);
-		write_float_a("fcalphase", bsd[i].fcalphase, 2);
-		write_float_a("fcaltilt", bsd[i].fcaltilt,2);
-		write_float_a("fcalcurve", bsd[i].fcalcurve,2);
-		write_float_a("fcalgibpha", bsd[i].fcalgibpha,2);
-		write_float_a("fcalgibmag", bsd[i].fcalgibmag,2);
-	}
-}
-*/
+
 void config_set_lighthouse(struct BaseStationData* bsd, uint8_t idx) {
-	config_set_uint32("index", idx);
-	config_set_uint32("id", bsd->BaseStationID);
-	config_set_float_a("position", bsd->Position, 3);
-	config_set_float_a("quaternion", bsd->Quaternion, 4);
-	config_set_float_a("fcalphase", bsd->fcalphase, 2);
-	config_set_float_a("fcaltilt", bsd->fcaltilt,2);
-	config_set_float_a("fcalcurve", bsd->fcalcurve,2);
-	config_set_float_a("fcalgibpha", bsd->fcalgibpha,2);
-	config_set_float_a("fcalgibmag", bsd->fcalgibmag,2);
+	config_group *cg = lh_config+idx;
+	config_set_uint32(cg,"index", idx);
+	config_set_uint32(cg,"id", bsd->BaseStationID);
+	config_set_float_a(cg,"position", bsd->Position, 3);
+	config_set_float_a(cg,"quaternion", bsd->Quaternion, 4);
+	config_set_float_a(cg,"fcalphase", bsd->fcalphase, 2);
+	config_set_float_a(cg,"fcaltilt", bsd->fcaltilt,2);
+	config_set_float_a(cg,"fcalcurve", bsd->fcalcurve,2);
+	config_set_float_a(cg,"fcalgibpha", bsd->fcalgibpha,2);
+	config_set_float_a(cg,"fcalgibmag", bsd->fcalgibmag,2);
 }
 
 void sstrcpy(char** dest, const char *src) {
 	uint32_t len = strlen(src)+1;
+	assert(dest!=NULL);
+
 	if (*dest == NULL) {
 		*dest = (char*)malloc(len);
 	} else {
@@ -111,71 +72,50 @@ void sstrcpy(char** dest, const char *src) {
 	strcpy(*dest,src);
 }
 
-config_val* find_config_entry(const char *tag) {
+config_entry* find_config_entry(config_group *cg, const char *tag) {
 	uint16_t i = 0;
-	for (i=0;i<used_entries;++i) {
-		if ( strcmp(config_values[i].tag, tag) == 0 ) {
-			return config_values+i;
+	for (i=0;i < cg->used_entries;++i) {
+		if ( strcmp(cg->config_entries[i].tag, tag) == 0 ) {
+			return cg->config_entries+i;
 		}
 	}
 	return NULL;
 }
 
-const char* config_read_str(const char *tag, const char *value, const char *def_str) {
-	config_val *cv = find_config_entry(tag);
+const char* config_read_str(config_group *cg, const char *tag, const char *def) {
+	config_entry *cv = find_config_entry(cg, tag);
 
 	if (cv != NULL) return cv->data;
 
-	assert(used_entries<MAX_CONFIG_ENTRIES);
-
-	used_entries++;
-	sstrcpy(&(cv->tag), tag);
-	sstrcpy(&(cv->data), def_str);
-	cv->type = CONFIG_STRING;
-
-	return cv->data;
+	return config_set_str(cg,tag,def);
 }
 
-uint32_t config_read_uint32(const char *tag, const uint32_t value, const uint32_t def) {
-	config_val *cv = find_config_entry(tag);
+uint32_t config_read_uint32(config_group *cg, const char *tag, const uint32_t def) {
+	config_entry *cv = find_config_entry(cg, tag);
 
 	if (cv != NULL) return cv->numeric.i;
 
-	assert(used_entries<MAX_CONFIG_ENTRIES);
-
-	used_entries++;
-	sstrcpy(&(cv->tag), tag);
-	cv->numeric.i = def;
-	cv->type = CONFIG_UINT32;
-
-	return cv->numeric.i;
+	return config_set_uint32(cg, tag, def);
 }
 
-FLT config_read_float(const char *tag, const FLT value, const FLT def) {
-	config_val *cv = find_config_entry(tag);
+FLT config_read_float(config_group *cg, const char *tag, const FLT def) {
+	config_entry *cv = find_config_entry(cg, tag);
 
 	if (cv != NULL) return cv->numeric.f;
 
-	assert(used_entries<MAX_CONFIG_ENTRIES);
-
-	used_entries++;
-	sstrcpy(&(cv->tag), tag);
-	cv->numeric.f = def;
-	cv->type = CONFIG_FLOAT;
-
-	return cv->numeric.f;
+	config_set_float(cg, tag, def);
 }
 
-config_val* next_unused_val() {
-	config_val *cv = config_values+used_entries;
-	assert(used_entries<MAX_CONFIG_ENTRIES);
-	used_entries++;
+config_entry* next_unused_entry(config_group *cg) {
+	config_entry *cv = cg->config_entries + cg->used_entries;
+	assert(cg->used_entries < cg->max_entries);
+	cg->used_entries++;
 	return cv;
 }
 
-const char* config_set_str(const char *tag, const char* value) {
-	config_val *cv = find_config_entry(tag);
-	if (cv == NULL) cv = next_unused_val();
+const char* config_set_str(config_group *cg, const char *tag, const char* value) {
+	config_entry *cv = find_config_entry(cg, tag);
+	if (cv == NULL) cv = next_unused_entry(cg);
 
 	sstrcpy(&(cv->tag), tag);
 	sstrcpy(&(cv->data), value);
@@ -184,9 +124,9 @@ const char* config_set_str(const char *tag, const char* value) {
 	return value;
 }
 
-const uint32_t config_set_uint32(const char *tag, const uint32_t value) {
-	config_val *cv = find_config_entry(tag);
-	if (cv == NULL) cv = next_unused_val();
+const uint32_t config_set_uint32(config_group *cg, const char *tag, const uint32_t value) {
+	config_entry *cv = find_config_entry(cg, tag);
+	if (cv == NULL) cv = next_unused_entry(cg);
 
 	sstrcpy(&(cv->tag), tag);
 	cv->numeric.i = value;
@@ -195,9 +135,9 @@ const uint32_t config_set_uint32(const char *tag, const uint32_t value) {
 	return value;
 }
 
-const FLT config_set_float(const char *tag, const FLT value) {
-	config_val *cv = find_config_entry(tag);
-	if (cv == NULL) cv = next_unused_val();
+const FLT config_set_float(config_group *cg, const char *tag, const FLT value) {
+	config_entry *cv = find_config_entry(cg, tag);
+	if (cv == NULL) cv = next_unused_entry(cg);
 
 	sstrcpy(&(cv->tag), tag);
 	cv->numeric.f = value;
@@ -206,9 +146,9 @@ const FLT config_set_float(const char *tag, const FLT value) {
 	return value;
 }
 
-const FLT* config_set_float_a(const char *tag, const FLT* values, uint8_t count) {
-	config_val *cv = find_config_entry(tag);
-	if (cv == NULL) cv = next_unused_val();
+const FLT* config_set_float_a(config_group *cg, const char *tag, const FLT* values, uint8_t count) {
+	config_entry *cv = find_config_entry(cg, tag);
+	if (cv == NULL) cv = next_unused_entry(cg);
 
 	sstrcpy(&(cv->tag), tag);
 
@@ -231,23 +171,41 @@ void _json_write_float_array(FILE* f, const char* tag, FLT* v, uint8_t count) {
 	json_write_double_array(f,tag,v,count);
 }
 
-void config_save(const char* path) {
+void write_config_group(FILE* f, config_group *cg, char *tag) {
 	uint16_t i = 0;
 
-	FILE* f = fopen(path, "w");
+	if (tag != NULL) {
+		fprintf(f, "\"%s\":{\n", tag);
+	}
 
-	for (i=0;i<=used_entries;++i) {
-		if (config_values[i].type == CONFIG_FLOAT) {
-			json_write_float(f, config_values[i].tag, config_values[i].numeric.f);
-		} else if (config_values[i].type == CONFIG_UINT32) {
-			json_write_uint32(f, config_values[i].tag, config_values[i].numeric.i);
-		} else if (config_values[i].type == CONFIG_STRING) {
-			json_write_str(f, config_values[i].tag, config_values[i].data);
-		} else if (config_values[i].type == CONFIG_FLOAT_ARRAY) {
-			_json_write_float_array(f, config_values[i].tag, (FLT*)config_values[i].data, config_values[i].elements);
+	for (i=0;i < cg->used_entries;++i) {
+		if (cg->config_entries[i].type == CONFIG_FLOAT) {
+			json_write_float(f, cg->config_entries[i].tag, cg->config_entries[i].numeric.f);
+		} else if (cg->config_entries[i].type == CONFIG_UINT32) {
+			json_write_uint32(f, cg->config_entries[i].tag, cg->config_entries[i].numeric.i);
+		} else if (cg->config_entries[i].type == CONFIG_STRING) {
+			json_write_str(f, cg->config_entries[i].tag, cg->config_entries[i].data);
+		} else if (cg->config_entries[i].type == CONFIG_FLOAT_ARRAY) {
+			_json_write_float_array(f, cg->config_entries[i].tag, (FLT*)cg->config_entries[i].data, cg->config_entries[i].elements);
 		}
+		if ((i+1) < cg->used_entries) fprintf(f,",");
+		fprintf(f,"\n");
 	};
 
+	if (tag != NULL) {
+		fprintf(f,"}\n");
+	}
+}
+
+void config_save(const char* path) {
+	uint16_t i = 0;
+
+	FILE* f = fopen(path, "w");
+
+	write_config_group(f,&global_config_values, NULL);
+	write_config_group(f,lh_config, "lighthouse0");
+	write_config_group(f,lh_config+1, "lighthouse1");
+
 	fclose(f);
 }
 
-- 
cgit v1.2.3


From 77644ff26ee7b8fcef3997d0ffe183d0a80c85e4 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Mon, 27 Feb 2017 21:52:39 -0500
Subject: return set float value

---
 src/survive_config.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index dfbd0e2..2ed265b 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -103,7 +103,7 @@ FLT config_read_float(config_group *cg, const char *tag, const FLT def) {
 
 	if (cv != NULL) return cv->numeric.f;
 
-	config_set_float(cg, tag, def);
+	return config_set_float(cg, tag, def);
 }
 
 config_entry* next_unused_entry(config_group *cg) {
-- 
cgit v1.2.3


From b0dc9c89146d2a5904a4ecc6b9c1f8d1c5fcfce0 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Mon, 27 Feb 2017 22:00:35 -0500
Subject: check for correct float size

---
 src/survive_config.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index 2ed265b..5531006 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -168,7 +168,11 @@ const FLT* config_set_float_a(config_group *cg, const char *tag, const FLT* valu
 }
 
 void _json_write_float_array(FILE* f, const char* tag, FLT* v, uint8_t count) {
-	json_write_double_array(f,tag,v,count);
+	if (sizeof(FLT) == sizeof(double)) {
+		json_write_double_array(f,tag,v,count);
+	} else if (sizeof(FLT) == sizeof(float)) {
+		json_write_double_array(f,tag,v,count);
+	}
 }
 
 void write_config_group(FILE* f, config_group *cg, char *tag) {
-- 
cgit v1.2.3


From 6cc609204ba7ea1bd0a903cf918a2b7eea979b91 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Mon, 27 Feb 2017 22:08:36 -0500
Subject: compile time check of float type

---
 src/survive_config.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index 5531006..c46e300 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -168,11 +168,11 @@ const FLT* config_set_float_a(config_group *cg, const char *tag, const FLT* valu
 }
 
 void _json_write_float_array(FILE* f, const char* tag, FLT* v, uint8_t count) {
-	if (sizeof(FLT) == sizeof(double)) {
+	#ifdef USE_DOUBLE
 		json_write_double_array(f,tag,v,count);
-	} else if (sizeof(FLT) == sizeof(float)) {
-		json_write_double_array(f,tag,v,count);
-	}
+	#else
+		json_write_float_array(f,tag,v,count);
+	#endif
 }
 
 void write_config_group(FILE* f, config_group *cg, char *tag) {
-- 
cgit v1.2.3


From 0ebe84be5824202aecfd87ac58005afa76b36be9 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Mon, 6 Mar 2017 22:05:02 -0500
Subject: Load strings from config files. I need to finish the loading of
 numeric values and arrays.

---
 src/survive_config.c | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index c46e300..d91596f 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -109,6 +109,14 @@ FLT config_read_float(config_group *cg, const char *tag, const FLT def) {
 config_entry* next_unused_entry(config_group *cg) {
 	config_entry *cv = cg->config_entries + cg->used_entries;
 	assert(cg->used_entries < cg->max_entries);
+
+/*
+	if (cg->used_entries >= cg->max_entries) {
+		cg->max_entries+=10;
+		cg->config_entries = realloc(cg->config_entries, sizeof(config_entry)*cg->max_entries);
+	}
+*/
+
 	cg->used_entries++;
 	return cv;
 }
@@ -213,3 +221,52 @@ void config_save(const char* path) {
 	fclose(f);
 }
 
+void print_json_value(char* tag, char** values, uint16_t count) {
+	uint16_t i = 0;
+	for (i=0;i<count; ++i) {
+		printf("%s:%s \n", tag, values[i]);
+	}
+}
+
+config_group* cg_stack[10]; //handle 10 nested objects deep
+uint8_t cg_stack_head = 0;
+
+void handle_config_group(char* tag) {
+	cg_stack_head++;
+	if (strcmp("lighthouse0",tag) == 0) {
+		cg_stack[cg_stack_head] = lh_config;
+	} else if (strcmp("lighthouse1",tag) == 0) {
+		cg_stack[cg_stack_head] = lh_config+1;
+	} else {
+		cg_stack[cg_stack_head] = &global_config_values;
+	}
+}
+
+void pop_config_group() {
+	cg_stack_head--;
+}
+
+void handle_tag_value(char* tag, char** values, uint16_t count) {
+	print_json_value(tag,values,count);
+	config_group* cg = cg_stack[cg_stack_head];
+
+	//parse out numeric values
+
+	if (count == 1) config_set_str(cg,tag,values[0]);
+//	else if (count>1) config_set_str
+}
+
+void config_read(const char* path) {
+	json_begin_object = handle_config_group;
+	json_end_object = pop_config_group;
+	json_tag_value = handle_tag_value;
+
+	cg_stack[0] = &global_config_values;
+
+	json_load_file(path);
+
+	json_begin_object = NULL;
+	json_end_object = NULL;
+	json_tag_value = NULL;
+}
+
-- 
cgit v1.2.3


From a7b423ba1f0b28d0e6f3f375475cf93d66b922c9 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Mon, 6 Mar 2017 22:21:15 -0500
Subject: remove unused function

---
 src/survive_config.c | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index d91596f..83951fb 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -14,7 +14,7 @@ config_group lh_config[MAX_LIGHTHOUSES]; //lighthouse configs
 
 //static uint16_t used_entries = 0;
 
-static FILE *config_file = NULL;
+//static FILE *config_file = NULL;
 const FLT* config_set_float_a(config_group *cg, const char *tag, const FLT* values, uint8_t count);
 
 void init_config_group(config_group *cg, uint16_t count) {
@@ -39,13 +39,6 @@ void config_init() {
 	}
 }
 
-void config_load(const char* path) {
-	config_file = fopen(path, "r");
-}
-
-void config_close() {
-	fclose(config_file);
-}
 
 void config_set_lighthouse(struct BaseStationData* bsd, uint8_t idx) {
 	config_group *cg = lh_config+idx;
-- 
cgit v1.2.3


From 90ed96e7b59e60a39f1e1f33223c6ffb0ee833f7 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Tue, 7 Mar 2017 20:33:19 -0500
Subject: parse out integers and floats

---
 src/survive_config.c | 81 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 79 insertions(+), 2 deletions(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index 83951fb..d8bad17 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -4,6 +4,8 @@
 #include "survive_config.h"
 #include <json_helpers.h>
 
+#include <errno.h>
+
 #define MAX_CONFIG_ENTRIES 100
 #define MAX_LIGHTHOUSES 2
 
@@ -99,6 +101,21 @@ FLT config_read_float(config_group *cg, const char *tag, const FLT def) {
 	return config_set_float(cg, tag, def);
 }
 
+uint16_t config_read_float_array(config_group *cg, const char *tag, FLT** values, const FLT* def, uint16_t count) {
+	config_entry *cv = find_config_entry(cg, tag);
+
+	if (cv != NULL) {
+		*values = (FLT*)cv->data;
+		return cv->elements;
+	}
+
+	if (def == NULL) return 0;
+
+	config_set_float_a(cg, tag, def, count);
+	*values = def;
+	return count;
+}
+
 config_entry* next_unused_entry(config_group *cg) {
 	config_entry *cv = cg->config_entries + cg->used_entries;
 	assert(cg->used_entries < cg->max_entries);
@@ -239,13 +256,73 @@ void pop_config_group() {
 	cg_stack_head--;
 }
 
+
+int parse_floats(char* tag, char** values, uint16_t count) {
+	uint16_t i = 0;
+	FLT f[count];
+	char* end = NULL;
+	config_group* cg = cg_stack[cg_stack_head];
+
+	for(i=0;i<count;++i) {
+
+		#ifdef USE_DOUBLE
+		f[i] = strtod(values[i], &end);
+		#else
+		f[i] = strtof(values[i], &end);
+		#endif
+
+//		if (values[i] == end) return 0; //not a float
+		if (*end != '\0') return 0; //not an integer
+	}
+
+	if (count>1) {
+		config_set_float_a(cg, tag, f, count);
+	}
+	else {
+		config_set_float(cg, tag, f[0]);
+	}
+
+	return 1;
+}
+
+int parse_uint32(char* tag, char** values, uint16_t count) {
+	uint16_t i = 0;
+	uint32_t l[count];
+	char* end = NULL;
+	config_group* cg = cg_stack[cg_stack_head];
+
+/*
+	//look for non numeric values
+	for(end=values[0];*end!='\0';++end) {
+		if ((*end<48) || (*end>57)) return 0;
+	}
+
+	end=NULL;
+*/
+	for(i=0;i<count;++i) {
+		l[i] = strtol(values[i], &end, 10);
+//		if (values[i] == end) return 0; //not an integer
+		if (*end != '\0') return 0; //not an integer
+	}
+
+//	if (count>1)
+//		config_set_uint32_array(cg, tag, f, count);
+//	else
+		config_set_uint32(cg, tag, l[0]);
+
+	return 1;
+}
+
 void handle_tag_value(char* tag, char** values, uint16_t count) {
 	print_json_value(tag,values,count);
 	config_group* cg = cg_stack[cg_stack_head];
 
-	//parse out numeric values
+	if (parse_uint32(tag,values,count) > 0) return; //parse integers first, stricter rules
+
+	if (parse_floats(tag,values,count) > 0) return;
 
-	if (count == 1) config_set_str(cg,tag,values[0]);
+	//should probably also handle string arrays
+	config_set_str(cg,tag,values[0]);
 //	else if (count>1) config_set_str
 }
 
-- 
cgit v1.2.3


From 6613cdc174401379b88f253385e8f82304de42f5 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Tue, 7 Mar 2017 21:20:39 -0500
Subject: simplify use of realloc

---
 src/survive_config.c | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index d8bad17..23d7ef1 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -59,11 +59,10 @@ void sstrcpy(char** dest, const char *src) {
 	uint32_t len = strlen(src)+1;
 	assert(dest!=NULL);
 
-	if (*dest == NULL) {
-		*dest = (char*)malloc(len);
-	} else {
-		*dest = (char*)realloc(*dest, len);
-	}
+	char* ptr = (char*)realloc(*dest, len); //acts like mallos if dest==NULL
+	assert(ptr!=NULL);
+	*dest = ptr;
+
 	strcpy(*dest,src);
 }
 
@@ -170,12 +169,10 @@ const FLT* config_set_float_a(config_group *cg, const char *tag, const FLT* valu
 
 	sstrcpy(&(cv->tag), tag);
 
-	if (cv->data == NULL) {
-		cv->data = (char*)malloc(sizeof(FLT)*count);
-	}
-	else {
-		cv->data = (char*)realloc(cv->data, sizeof(FLT)*count);
-	}
+	char* ptr = (char*)realloc(cv->data, sizeof(FLT)*count);
+	assert(ptr!=NULL);
+	cv->data = ptr;
+
 	printf("float array\n");
 
 	memcpy(cv->data,values,sizeof(FLT)*count);
-- 
cgit v1.2.3


From be3b6becc78ca68287e2570eea292535fc3327ec Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Tue, 7 Mar 2017 21:24:32 -0500
Subject: dynamically expand config_entries in config_group

---
 src/survive_config.c | 35 ++++++++++++++++++++++++++---------
 1 file changed, 26 insertions(+), 9 deletions(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index 23d7ef1..b59bd85 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -33,6 +33,26 @@ void init_config_group(config_group *cg, uint16_t count) {
 	}
 }
 
+void resize_config_group(config_group *cg, uint16_t count) {
+	uint16_t i = 0;
+
+	if (count > cg->max_entries) {
+		config_entry* ptr = realloc(cg->config_entries, sizeof(config_entry)*count);
+		assert(ptr!=NULL);
+
+		cg->config_entries = ptr;
+
+		for (i=cg->max_entries;i<count;++i) {
+			cg->config_entries[i].data = NULL;
+			cg->config_entries[i].tag = NULL;
+			cg->config_entries[i].type = CONFIG_UNKNOWN;
+			cg->config_entries[i].elements = 0;
+		}
+
+		cg->max_entries = count;
+	}
+}
+
 void config_init() {
 	uint16_t i = 0;
 	init_config_group(&global_config_values, MAX_CONFIG_ENTRIES);
@@ -59,7 +79,7 @@ void sstrcpy(char** dest, const char *src) {
 	uint32_t len = strlen(src)+1;
 	assert(dest!=NULL);
 
-	char* ptr = (char*)realloc(*dest, len); //acts like mallos if dest==NULL
+	char* ptr = (char*)realloc(*dest, len); //acts like malloc if dest==NULL
 	assert(ptr!=NULL);
 	*dest = ptr;
 
@@ -116,15 +136,12 @@ uint16_t config_read_float_array(config_group *cg, const char *tag, FLT** values
 }
 
 config_entry* next_unused_entry(config_group *cg) {
-	config_entry *cv = cg->config_entries + cg->used_entries;
-	assert(cg->used_entries < cg->max_entries);
+	config_entry *cv = NULL;
+//	assert(cg->used_entries < cg->max_entries);
 
-/*
-	if (cg->used_entries >= cg->max_entries) {
-		cg->max_entries+=10;
-		cg->config_entries = realloc(cg->config_entries, sizeof(config_entry)*cg->max_entries);
-	}
-*/
+	if (cg->used_entries >= cg->max_entries) resize_config_group(cg, cg->max_entries + 10);
+
+	cv = cg->config_entries + cg->used_entries;
 
 	cg->used_entries++;
 	return cv;
-- 
cgit v1.2.3


From 57e82519b4844620851784e7682a2c562cb06d47 Mon Sep 17 00:00:00 2001
From: Joshua Allen <axlecrusher@gmail.com>
Date: Tue, 7 Mar 2017 21:39:40 -0500
Subject: add init and destroy functions for config_entry

---
 src/survive_config.c | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index b59bd85..f30bf87 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -9,8 +9,6 @@
 #define MAX_CONFIG_ENTRIES 100
 #define MAX_LIGHTHOUSES 2
 
-
-
 config_group global_config_values;
 config_group lh_config[MAX_LIGHTHOUSES]; //lighthouse configs
 
@@ -19,6 +17,18 @@ config_group lh_config[MAX_LIGHTHOUSES]; //lighthouse configs
 //static FILE *config_file = NULL;
 const FLT* config_set_float_a(config_group *cg, const char *tag, const FLT* values, uint8_t count);
 
+void init_config_entry(config_entry* ce) {
+	ce->data = NULL;
+	ce->tag = NULL;
+	ce->type = CONFIG_UNKNOWN;
+	ce->elements = 0;
+}
+
+void destroy_config_entry(config_entry* ce) {
+	if (ce->tag!=NULL) free(ce->tag);
+	if (ce->data!=NULL) free(ce->data);
+}
+
 void init_config_group(config_group *cg, uint16_t count) {
 	uint16_t i = 0;
 	cg->config_entries = malloc(count*sizeof(config_entry));
@@ -26,10 +36,7 @@ void init_config_group(config_group *cg, uint16_t count) {
 	cg->max_entries = count;
 
 	for (i=0;i<count;++i) {
-		cg->config_entries[i].data = NULL;
-		cg->config_entries[i].tag = NULL;
-		cg->config_entries[i].type = CONFIG_UNKNOWN;
-		cg->config_entries[i].elements = 0;
+		init_config_entry(cg->config_entries+i);
 	}
 }
 
@@ -43,10 +50,7 @@ void resize_config_group(config_group *cg, uint16_t count) {
 		cg->config_entries = ptr;
 
 		for (i=cg->max_entries;i<count;++i) {
-			cg->config_entries[i].data = NULL;
-			cg->config_entries[i].tag = NULL;
-			cg->config_entries[i].type = CONFIG_UNKNOWN;
-			cg->config_entries[i].elements = 0;
+			init_config_entry(cg->config_entries+i);
 		}
 
 		cg->max_entries = count;
-- 
cgit v1.2.3


From 394cbc465e776137834eea830038b43ea98f6268 Mon Sep 17 00:00:00 2001
From: cnlohr <lohr85@gmail.com>
Date: Wed, 8 Mar 2017 00:30:48 -0500
Subject: Switch types over to avoiding extra struct keyword.  Switch poses to
 "SurvivePose" type.

---
 src/survive_config.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'src/survive_config.c')

diff --git a/src/survive_config.c b/src/survive_config.c
index f30bf87..352a15b 100644
--- a/src/survive_config.c
+++ b/src/survive_config.c
@@ -66,12 +66,11 @@ void config_init() {
 }
 
 
-void config_set_lighthouse(struct BaseStationData* bsd, uint8_t idx) {
+void config_set_lighthouse(BaseStationData* bsd, uint8_t idx) {
 	config_group *cg = lh_config+idx;
 	config_set_uint32(cg,"index", idx);
 	config_set_uint32(cg,"id", bsd->BaseStationID);
-	config_set_float_a(cg,"position", bsd->Position, 3);
-	config_set_float_a(cg,"quaternion", bsd->Quaternion, 4);
+	config_set_float_a(cg,"pose", &bsd->Pose.Pos[0], 7);
 	config_set_float_a(cg,"fcalphase", bsd->fcalphase, 2);
 	config_set_float_a(cg,"fcaltilt", bsd->fcaltilt,2);
 	config_set_float_a(cg,"fcalcurve", bsd->fcalcurve,2);
-- 
cgit v1.2.3