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.h | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'src/survive_config.h')

diff --git a/src/survive_config.h b/src/survive_config.h
index 24762cd..3e62ec8 100644
--- a/src/survive_config.h
+++ b/src/survive_config.h
@@ -10,7 +10,8 @@ typedef enum {
 	CONFIG_UNKNOWN = 0,
 	CONFIG_FLOAT = 1,
 	CONFIG_UINT32 = 2,
-	CONFIG_STRING = 3
+	CONFIG_STRING = 3,
+	CONFIG_FLOAT_ARRAY = 4,
 } cval_type;
 /*
 typedef union {
@@ -25,13 +26,15 @@ typedef struct {
 		uint32_t i;
 		FLT f;
 	} numeric;
-	char *str;
+	char *data;
+	uint32_t elements;
 } config_val;
 
-
+void config_init();
 void config_open(const char* path, const char* mode);
 void config_close();
 void config_write_lighthouse(struct BaseStationData* bsd, uint8_t length);
+void config_set_lighthouse(struct BaseStationData* bsd, uint8_t idx);
 
 void config_save(const char* path);
 const FLT config_set_float(const char *tag, const FLT value);
-- 
cgit v1.3.1


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

---
 calibrate.c           |   3 +
 calibrate_client.c    |   8 ++
 redist/json_helpers.c |  11 +--
 src/survive_cal.c     |   5 ++
 src/survive_config.c  | 230 +++++++++++++++++++++-----------------------------
 src/survive_config.h  |  34 +++++---
 6 files changed, 136 insertions(+), 155 deletions(-)

(limited to 'src/survive_config.h')

diff --git a/calibrate.c b/calibrate.c
index 8eedc88..9c01e8a 100644
--- a/calibrate.c
+++ b/calibrate.c
@@ -10,6 +10,8 @@
 #include "src/survive_cal.h"
 #include <DrawFunctions.h>
 
+#include "src/survive_config.h"
+
 struct SurviveContext * ctx;
 
 void HandleKey( int keycode, int bDown )
@@ -141,6 +143,7 @@ void * GuiThread( void * v )
 int main()
 {
 	ctx = survive_init( 0 );
+	config_init();
 
 	survive_install_light_fn( ctx,  my_light_process );
 	survive_install_imu_fn( ctx,  my_imu_process );
diff --git a/calibrate_client.c b/calibrate_client.c
index 25b6303..897c9e0 100644
--- a/calibrate_client.c
+++ b/calibrate_client.c
@@ -10,6 +10,8 @@
 #include "src/survive_cal.h"
 #include <DrawFunctions.h>
 
+#include "src/survive_config.h"
+
 struct SurviveContext * ctx;
 
 void HandleKey( int keycode, int bDown )
@@ -152,6 +154,12 @@ int main()
 	CNFGDialogColor = 0x444444;
 	CNFGSetup( "Survive GUI Debug", 640, 480 );
 	OGCreateThread( GuiThread, 0 );
+
+	config_init();
+	config_set_str(&global_config_values, "Hello","World!");
+	const char *s = config_read_str(&global_config_values, "TestStr","This is a test.");
+	printf("%s\n", s);
+	config_save("config.json");
 	
 
 	if( !ctx )
diff --git a/redist/json_helpers.c b/redist/json_helpers.c
index e96e873..74028b2 100644
--- a/redist/json_helpers.c
+++ b/redist/json_helpers.c
@@ -3,6 +3,7 @@
 #define _GNU_SOURCE
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include "json_helpers.h"
 
@@ -22,7 +23,7 @@ void json_write_float_array(FILE* f, const char* tag, float* v, uint8_t count) {
 		str1=str2;
 		str2=NULL;
 	}
-	asprintf(&str2, "%s]\n", str1,v[i]);
+	asprintf(&str2, "%s]", str1,v[i]);
 	fputs(str2,f);
 	free(str1);
 	free(str2);
@@ -44,20 +45,20 @@ void json_write_double_array(FILE* f, const char* tag, double* v, uint8_t count)
 		str1=str2;
 		str2=NULL;
 	}
-	asprintf(&str2, "%s]\n", str1,v[i]);
+	asprintf(&str2, "%s]", str1,v[i]);
 	fputs(str2,f);
 	free(str1);
 	free(str2);
 }
 
 void json_write_uint32(FILE* f, const char* tag, uint32_t v) {
-	fprintf(f, "\"%s\":\"%d\"\n", tag, v);
+	fprintf(f, "\"%s\":\"%d\"", tag, v);
 }
 
 void json_write_float(FILE* f, const char* tag, float v) {
-	fprintf(f, "\"%s\":\"%f\"\n", tag, v);
+	fprintf(f, "\"%s\":\"%f\"", tag, v);
 }
 
 void json_write_str(FILE* f, const char* tag, const char* v) {
-	fprintf(f, "\"%s\":\"%s\"\n", tag, v);
+	fprintf(f, "\"%s\":\"%s\"", tag, v);
 }
\ No newline at end of file
diff --git a/src/survive_cal.c b/src/survive_cal.c
index 760692c..41d3fb1 100644
--- a/src/survive_cal.c
+++ b/src/survive_cal.c
@@ -15,6 +15,8 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
+#include "survive_config.h"
+
 #define PTS_BEFORE_COMMON 32
 #define NEEDED_COMMON_POINTS 10
 #define NEEDED_TIMES_OF_COMMON 5
@@ -49,6 +51,9 @@ void ootx_packet_clbk_d(ootx_decoder_context *ct, ootx_packet* packet)
 	b->fcalgibmag[0] = v6.fcal_0_gibmag;
 	b->fcalgibmag[1] = v6.fcal_1_gibmag;
 	b->OOTXSet = 1;
+
+	config_set_lighthouse(b,id);
+	config_save("config.json");
 }
 
 int survive_cal_get_status( struct SurviveContext * ctx, char * description, int description_length )
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);
 }
 
diff --git a/src/survive_config.h b/src/survive_config.h
index 3e62ec8..14e2fc6 100644
--- a/src/survive_config.h
+++ b/src/survive_config.h
@@ -13,12 +13,8 @@ typedef enum {
 	CONFIG_STRING = 3,
 	CONFIG_FLOAT_ARRAY = 4,
 } cval_type;
-/*
-typedef union {
-		uint32_t i;
-		FLT f;
-	} Numeric;
-*/
+
+
 typedef struct {
 	char *tag;
 	cval_type type;
@@ -28,21 +24,31 @@ typedef struct {
 	} numeric;
 	char *data;
 	uint32_t elements;
-} config_val;
+} config_entry;
+
+typedef struct {
+	config_entry *config_entries;
+	uint16_t	used_entries;
+	uint16_t	max_entries;
+} config_group;
+
+extern config_group global_config_values;
+extern config_group lh_config[2]; //lighthouse configs
+
 
 void config_init();
 void config_open(const char* path, const char* mode);
 void config_close();
-void config_write_lighthouse(struct BaseStationData* bsd, uint8_t length);
+//void config_write_lighthouse(struct BaseStationData* bsd, uint8_t length);
 void config_set_lighthouse(struct BaseStationData* bsd, uint8_t idx);
 
 void config_save(const char* path);
-const FLT config_set_float(const char *tag, const FLT value);
-const uint32_t config_set_uint32(const char *tag, const uint32_t value);
-const char* config_set_str(const char *tag, const char* value);
-FLT config_read_float(const char *tag, const FLT value, const FLT def);
+const FLT config_set_float(config_group *cg, const char *tag, const FLT value);
+const uint32_t config_set_uint32(config_group *cg, const char *tag, const uint32_t value);
+const char* config_set_str(config_group *cg, const char *tag, const char* value);
 
-uint32_t config_read_uint32(const char *tag, const uint32_t value, const uint32_t def);
-const char* config_read_str(const char *tag, const char *value, const char *def_str);
+FLT config_read_float(config_group *cg, const char *tag, const FLT def);
+uint32_t config_read_uint32(config_group *cg, const char *tag, const uint32_t def);
+const char* config_read_str(config_group *cg, const char *tag, const char *def);
 
 #endif
\ No newline at end of file
-- 
cgit v1.3.1


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.

---
 calibrate_client.c    |  18 ++++----
 redist/json_helpers.c | 114 ++++++++++++++++++++++++++++++++++++++++++++++++--
 redist/json_helpers.h |   6 +++
 src/survive_cal.c     |   2 +-
 src/survive_config.c  |  57 +++++++++++++++++++++++++
 src/survive_config.h  |   3 +-
 6 files changed, 188 insertions(+), 12 deletions(-)

(limited to 'src/survive_config.h')

diff --git a/calibrate_client.c b/calibrate_client.c
index 08f0715..927f40f 100644
--- a/calibrate_client.c
+++ b/calibrate_client.c
@@ -142,6 +142,17 @@ void * GuiThread( void * v )
 
 int main()
 {
+
+	config_init();
+	config_read("config.json");
+	config_set_str(&global_config_values, "Hello","World!");
+	const char *s = config_read_str(&global_config_values, "test123","default");
+	printf("%s\n", s);
+
+
+//	config_save("config.json");
+
+	
 	ctx = survive_init( 1 );
 
 	survive_install_light_fn( ctx,  my_light_process );
@@ -159,13 +170,6 @@ int main()
 	CNFGSetup( "Survive GUI Debug", 640, 480 );
 	OGCreateThread( GuiThread, 0 );
 
-	config_init();
-	config_set_str(&global_config_values, "Hello","World!");
-	const char *s = config_read_str(&global_config_values, "TestStr","This is a test.");
-	printf("%s\n", s);
-	config_save("config.json");
-	
-
 	if( !ctx )
 	{
 		fprintf( stderr, "Fatal. Could not start\n" );
diff --git a/redist/json_helpers.c b/redist/json_helpers.c
index fd04203..b7ccb40 100644
--- a/redist/json_helpers.c
+++ b/redist/json_helpers.c
@@ -6,6 +6,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include "json_helpers.h"
+#include <jsmn.h>
+
 
 void json_write_float_array(FILE* f, const char* tag, float* v, uint8_t count) {
 	uint8_t i = 0;
@@ -14,10 +16,10 @@ void json_write_float_array(FILE* f, const char* tag, float* v, uint8_t count) {
 	asprintf(&str1,"\"%s\":[", tag);
 
 	for (i=0;i<count;++i) {
-		if (i<(count-1)) {
-			asprintf(&str2, "%s\"%f\",", str1,v[i]);
-		} else {
+		if ( (i+1) < count) {
 			asprintf(&str2, "%s\"%f\"", str1,v[i]);
+		} else {
+			asprintf(&str2, "%s\"%f\",", str1,v[i]);
 		}
 		free(str1);
 		str1=str2;
@@ -62,3 +64,109 @@ void json_write_float(FILE* f, const char* tag, float v) {
 void json_write_str(FILE* f, const char* tag, const char* v) {
 	fprintf(f, "\"%s\":\"%s\"", tag, v);
 }
+
+
+
+
+void (*json_begin_object)(char* tag) = NULL;
+void (*json_end_object)() = NULL;
+void (*json_tag_value)(char* tag, char** values, uint16_t count) = NULL;
+
+uint32_t JSON_STRING_LEN;
+
+char* load_file_to_mem(const char* path) {
+	FILE * f = fopen( path, "r" );
+	fseek( f, 0, SEEK_END );
+	int len = ftell( f );
+	fseek( f, 0, SEEK_SET );
+	char * JSON_STRING = malloc( len );
+	fread( JSON_STRING, len, 1, f );
+	fclose( f );
+	return JSON_STRING;
+}
+
+static char* substr(const char* str, uint32_t start, uint32_t end, uint32_t npos) {
+	uint32_t l = end-start+1;
+
+	if (end<=start || end>=npos) return NULL;
+
+	char* x = malloc(l);
+	memcpy(x,str+start,l);
+	x[l-1] = '\0';
+	return x;
+}
+
+static uint16_t json_load_array(const char* JSON_STRING, jsmntok_t* tokens, uint16_t size, char* tag) {
+	jsmntok_t* t = tokens;
+	uint16_t i = 0;
+
+	char* values[size];
+
+	for (i=0;i<size;++i) {
+		t = tokens+i;
+		values[i] = substr(JSON_STRING, t->start, t->end, JSON_STRING_LEN);
+	}
+
+	if (json_tag_value != NULL) json_tag_value(tag, values, i);
+
+	for (i=0;i<size;++i) free(values[i]);
+
+	return size;
+}
+
+void json_load_file(const char* path) {
+	uint32_t i = 0;
+	char* JSON_STRING = load_file_to_mem(path);
+	JSON_STRING_LEN = strlen(JSON_STRING);
+
+	jsmn_parser parser;
+	jsmn_init(&parser);
+
+	uint32_t items = jsmn_parse(&parser, JSON_STRING, JSON_STRING_LEN, NULL, 0);
+	jsmntok_t* tokens = malloc(items * sizeof(jsmntok_t));
+
+	jsmn_init(&parser);
+	items = jsmn_parse(&parser, JSON_STRING, JSON_STRING_LEN, tokens, items);
+
+	int16_t children = -1;
+
+	for (i=0; i<items; i+=2)
+	{
+		//increment i on each successful tag + values combination, not individual tokens
+		jsmntok_t* tag_t = tokens+i;
+		jsmntok_t* value_t = tokens+i+1;
+
+		char* tag = substr(JSON_STRING, tag_t->start, tag_t->end, JSON_STRING_LEN);
+		char* value = substr(JSON_STRING, value_t->start, value_t->end, JSON_STRING_LEN);
+
+		printf("%d %d c:%d %d %s \n", tag_t->start, tag_t->end, tag_t->size, tag_t->type, tag);
+
+
+		if (value_t->type == JSMN_ARRAY) {
+			i += json_load_array(JSON_STRING, tokens+i+2,value_t->size, tag); //look at array children
+		} else if (value_t->type == JSMN_OBJECT) {
+			printf("Begin Object\n");
+			if (json_begin_object != NULL) json_begin_object(tag);
+			children = value_t->size +1; //+1 to account for this loop where we are not yed parsing children
+//			i += decode_jsmn_object(JSON_STRING, tokens+i+2,value_t->size);
+		}
+		else {
+			if (json_tag_value != NULL) json_tag_value(tag, &value, 1);
+		}
+
+		if (children>=0) children--;
+		if (children == 0) {
+			children = -1;
+			printf("End Object\n");
+			if (json_end_object!=NULL) json_end_object();
+		}
+
+//		printf("%d %s \n", value_t->type, tag);
+
+		free(tag);
+		free(value);
+	}
+
+	free(JSON_STRING);
+}
+
diff --git a/redist/json_helpers.h b/redist/json_helpers.h
index 8d6eb64..1670058 100644
--- a/redist/json_helpers.h
+++ b/redist/json_helpers.h
@@ -11,4 +11,10 @@ void json_write_uint32(FILE* f, const char* tag, uint32_t v);
 void json_write_float(FILE* f, const char* tag, float v);
 void json_write_str(FILE* f, const char* tag, const char* v);
 
+void json_load_file(const char* path);
+extern void (*json_begin_object)(char* tag);
+extern void (*json_end_object)();
+extern void (*json_tag_value)(char* tag, char** values, uint16_t count);
+
+
 #endif
\ No newline at end of file
diff --git a/src/survive_cal.c b/src/survive_cal.c
index f372309..33d1faa 100644
--- a/src/survive_cal.c
+++ b/src/survive_cal.c
@@ -53,7 +53,7 @@ void ootx_packet_clbk_d(ootx_decoder_context *ct, ootx_packet* packet)
 	b->OOTXSet = 1;
 
 	config_set_lighthouse(b,id);
-	config_save("config.json");
+//	config_save("config.json");
 }
 
 int survive_cal_get_status( struct SurviveContext * ctx, char * description, int description_length )
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;
+}
+
diff --git a/src/survive_config.h b/src/survive_config.h
index 14e2fc6..2610e2e 100644
--- a/src/survive_config.h
+++ b/src/survive_config.h
@@ -37,7 +37,8 @@ extern config_group lh_config[2]; //lighthouse configs
 
 
 void config_init();
-void config_open(const char* path, const char* mode);
+//void config_open(const char* path, const char* mode);
+void config_read(const char* path);
 void config_close();
 //void config_write_lighthouse(struct BaseStationData* bsd, uint8_t length);
 void config_set_lighthouse(struct BaseStationData* bsd, uint8_t idx);
-- 
cgit v1.3.1


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 +--------
 src/survive_config.h | 1 -
 2 files changed, 1 insertion(+), 9 deletions(-)

(limited to 'src/survive_config.h')

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;
diff --git a/src/survive_config.h b/src/survive_config.h
index 2610e2e..b14f928 100644
--- a/src/survive_config.h
+++ b/src/survive_config.h
@@ -39,7 +39,6 @@ extern config_group lh_config[2]; //lighthouse configs
 void config_init();
 //void config_open(const char* path, const char* mode);
 void config_read(const char* path);
-void config_close();
 //void config_write_lighthouse(struct BaseStationData* bsd, uint8_t length);
 void config_set_lighthouse(struct BaseStationData* bsd, uint8_t idx);
 
-- 
cgit v1.3.1


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

---
 calibrate_client.c   |  6 ++++
 src/survive_config.c | 81 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 src/survive_config.h |  1 +
 3 files changed, 86 insertions(+), 2 deletions(-)

(limited to 'src/survive_config.h')

diff --git a/calibrate_client.c b/calibrate_client.c
index 927f40f..9867d67 100644
--- a/calibrate_client.c
+++ b/calibrate_client.c
@@ -149,6 +149,12 @@ int main()
 	const char *s = config_read_str(&global_config_values, "test123","default");
 	printf("%s\n", s);
 
+	FLT *f;
+
+	uint16_t fs = config_read_float_array(lh_config+1, "fcalgibpha", &f, NULL, 0);
+	printf("%d\n", fs);
+	printf("===> %f %f\n", f[0], f[1]);
+
 
 //	config_save("config.json");
 
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
 }
 
diff --git a/src/survive_config.h b/src/survive_config.h
index b14f928..234db68 100644
--- a/src/survive_config.h
+++ b/src/survive_config.h
@@ -48,6 +48,7 @@ const uint32_t config_set_uint32(config_group *cg, const char *tag, const uint32
 const char* config_set_str(config_group *cg, const char *tag, const char* value);
 
 FLT config_read_float(config_group *cg, const char *tag, const FLT def);
+uint16_t config_read_float_array(config_group *cg, const char *tag, FLT** values, const FLT* def, uint16_t count);
 uint32_t config_read_uint32(config_group *cg, const char *tag, const uint32_t def);
 const char* config_read_str(config_group *cg, const char *tag, const char *def);
 
-- 
cgit v1.3.1


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.

---
 include/libsurvive/poser.h         | 22 ++++++------
 include/libsurvive/survive.h       |  8 ++---
 include/libsurvive/survive_types.h | 17 +++++----
 src/survive_cal.c                  |  6 ++--
 src/survive_cal.h                  | 14 ++++----
 src/survive_cal_lhfind.c           | 14 ++++----
 src/survive_config.c               |  5 ++-
 src/survive_config.h               |  4 +--
 src/survive_data.c                 |  4 +--
 src/survive_internal.h             | 34 ++++++++----------
 src/survive_process.c              | 12 +++----
 src/survive_vive.c                 | 74 ++++++++++++++++++++------------------
 12 files changed, 109 insertions(+), 105 deletions(-)

(limited to 'src/survive_config.h')

diff --git a/include/libsurvive/poser.h b/include/libsurvive/poser.h
index 4894acf..c514953 100644
--- a/include/libsurvive/poser.h
+++ b/include/libsurvive/poser.h
@@ -11,22 +11,22 @@ typedef enum PoserType_t
 	POSERDATA_FULL_SCENE, 	//Full, statified X, Y sweep data for both lighthouses.
 } PoserType;
 
-struct PoserData
+typedef struct
 {
 	PoserType pt;
 	uint8_t data[0];
-};
+} PoserData;
 
-struct PoserDataIMU
+typedef struct
 {
 	PoserType pt;
 	uint8_t datamask;  //0 = accel present, 1 = gyro present, 2 = mag present.
 	FLT accel[3];
 	FLT gyro[3];
 	FLT mag[3];
-};
+} PoserDataIMU;
 
-struct PoserDataLight
+typedef struct
 {
 	PoserType pt;
 	int sensor_id;
@@ -34,21 +34,21 @@ struct PoserDataLight
 	uint32_t timecode;  //In object-local ticks.
 	FLT length;			//In seconds
 	FLT angle;			//In radians from center of lighthouse.
-};
+} PoserDataLight;
 
-struct PoserDataFullScene
+typedef struct
 {
 	PoserType pt;
 
 	//If "lengths[...]" < 0, means not a valid piece of sweep information.
 	FLT  lengths[SENSORS_PER_OBJECT][NUM_LIGHTHOUSES][2];
-	FLT  angles [SENSORS_PER_OBJECT][NUM_LIGHTHOUSES][2];  //2 Axes
+	FLT  angles [SENSORS_PER_OBJECT][NUM_LIGHTHOUSES][2];  //2 Axes  (Angles in LH space)
 
-	struct PoserDataIMU lastimu;
-};
+	PoserDataIMU lastimu;
+} PoserDataFullScene;
 
 //When you register your posers using the internal system, 
-typedef int (*PoserCB)( struct SurviveObject * so, struct PoserData * pd );
+typedef int (*PoserCB)( SurviveObject * so, PoserData * pd );
 
 
 #endif
diff --git a/include/libsurvive/survive.h b/include/libsurvive/survive.h
index 536c7fb..20e50ca 100644
--- a/include/libsurvive/survive.h
+++ b/include/libsurvive/survive.h
@@ -4,14 +4,14 @@
 #include <stdint.h>
 #include "poser.h"
 
-struct SurviveContext;
+typedef struct SurviveContext SurviveContext;
 
 //DANGER: This structure may be redefined.  Note that it is logically split into 64-bit chunks
 //for optimization on 32- and 64-bit systems.
 
 struct SurviveObject
 {
-	struct SurviveContext * ctx;
+	SurviveContext * ctx;
 
 	char    codename[4];    //3 letters, null-terminated.  Currently HMD, WM0, WM1.
 	char    drivername[4];  //3 letters for driver.  Currently "HTC"
@@ -27,8 +27,8 @@ struct SurviveObject
 
 	//Pose Information, also "resolver" field.
 	FLT    PoseConfidence; //0..1
-	FLT    Position[3];
-	FLT    Rotation[4];
+	SurvivePose OutPose;
+	SurvivePose FromLHPose[NUM_LIGHTHOUSES]; //Optionally filled out by poser, contains computed position from each lighthouse.
 	void * PoserData;   //Initialized to zero, configured by poser, can be anything the poser wants.
 	PoserCB * PoserFn;
 
diff --git a/include/libsurvive/survive_types.h b/include/libsurvive/survive_types.h
index 593819f..6137774 100644
--- a/include/libsurvive/survive_types.h
+++ b/include/libsurvive/survive_types.h
@@ -9,6 +9,11 @@
 #endif
 #endif
 
+typedef struct SurvivePose
+{
+	FLT  Pos[3];
+	FLT  Rot[4];
+} SurvivePose;
 
 //Careful with this, you can't just add another one right now, would take minor changes in survive_data.c and the cal tools.
 //It will also require a recompile.  TODO: revisit this and correct the comment once fixed.
@@ -17,13 +22,13 @@
 #define INTBUFFSIZE			64
 #define SENSORS_PER_OBJECT	32
 
-struct SurviveObject;
-struct SurviveContext;
+typedef struct SurviveObject SurviveObject;
+typedef struct SurviveContext SurviveContext;
 
-typedef void (*text_feedback_func)( struct SurviveContext * ctx, const char * fault );
-typedef void (*light_process_func)( struct SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length );
-typedef void (*imu_process_func)( struct SurviveObject * so, int16_t * accelgyro, uint32_t timecode, int id );
-typedef void (*angle_process_func)( struct SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle );
+typedef void (*text_feedback_func)( SurviveContext * ctx, const char * fault );
+typedef void (*light_process_func)( SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length );
+typedef void (*imu_process_func)( SurviveObject * so, int16_t * accelgyro, uint32_t timecode, int id );
+typedef void (*angle_process_func)( SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle );
 
 #endif
 
diff --git a/src/survive_cal.c b/src/survive_cal.c
index 33d1faa..2acf51c 100644
--- a/src/survive_cal.c
+++ b/src/survive_cal.c
@@ -27,8 +27,8 @@ static void reset_calibration( struct SurviveCalData * cd );
 
 void ootx_packet_clbk_d(ootx_decoder_context *ct, ootx_packet* packet)
 {
-	struct SurviveContext * ctx = (struct SurviveContext*)(ct->user);
-	struct SurviveCalData * cd = ctx->calptr;
+	SurviveContext * ctx = (SurviveContext*)(ct->user);
+	SurviveCalData * cd = ctx->calptr;
 	int id = ct->user1;
 
 	SV_INFO( "Got OOTX packet %d %p", id, cd );
@@ -36,7 +36,7 @@ void ootx_packet_clbk_d(ootx_decoder_context *ct, ootx_packet* packet)
 	lighthouse_info_v6 v6;
 	init_lighthouse_info_v6(&v6, packet->data);
 
-	struct BaseStationData * b = &ctx->bsd[id];
+	BaseStationData * b = &ctx->bsd[id];
 	//print_lighthouse_info_v6(&v6);
 
 	b->BaseStationID = v6.id;
diff --git a/src/survive_cal.h b/src/survive_cal.h
index bb4eb32..a5e372e 100644
--- a/src/survive_cal.h
+++ b/src/survive_cal.h
@@ -21,21 +21,21 @@
 #include "ootx_decoder.h"
 #include "survive_internal.h"
 
-void survive_cal_install( struct SurviveContext * ctx );
-int survive_cal_get_status( struct SurviveContext * ctx, char * description, int description_length );
+void survive_cal_install( SurviveContext * ctx );
+int survive_cal_get_status( SurviveContext * ctx, char * description, int description_length );
 
 //void survive_cal_teardown( struct SurviveContext * ctx );
 
 //Called from survive_default_light_process
-void survive_cal_light( struct SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length  );
-void survive_cal_angle( struct SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle );
+void survive_cal_light( SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length  );
+void survive_cal_angle( SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle );
 
 #define MAX_SENSORS_TO_CAL 96
 #define DRPTS 1024
 #define MAX_CAL_PT_DAT (MAX_SENSORS_TO_CAL*NUM_LIGHTHOUSES*2)
 struct SurviveCalData
 {
-	struct SurviveContext * ctx;
+	SurviveContext * ctx;
 	//OOTX Data is sync'd off of the sync pulses coming from the lighthouses.
 	ootx_decoder_context ootx_decoders[NUM_LIGHTHOUSES];
 
@@ -57,7 +57,7 @@ struct SurviveCalData
 
 	int senid_of_checkpt; //This is a point on a watchman that can be used to check the lh solution.
 
-	struct SurviveObject * hmd;
+	SurviveObject * hmd;
 
 	//Stage:
 	// 0: Idle
@@ -68,7 +68,7 @@ struct SurviveCalData
 
 //The following function is not included in the core survive_cal and must be compiled from a camfind file.
 //It should use data for stage 4 and report if it found the 
-int survive_cal_lhfind( struct SurviveCalData * cd );
+int survive_cal_lhfind( SurviveCalData * cd );
 
 
 #endif
diff --git a/src/survive_cal_lhfind.c b/src/survive_cal_lhfind.c
index 93d9dc0..a1bb2cc 100644
--- a/src/survive_cal_lhfind.c
+++ b/src/survive_cal_lhfind.c
@@ -7,13 +7,13 @@
 #define MIN_HITS_FOR_VALID 10
 
 
-FLT static RunOpti(  struct SurviveCalData * cd, int lh, int print, FLT * LighthousePos, FLT * LighthouseQuat );
+FLT static RunOpti(  SurviveCalData * cd, int lh, int print, FLT * LighthousePos, FLT * LighthouseQuat );
 
 //Values used for RunTest()
 
-int survive_cal_lhfind( struct SurviveCalData * cd )
+int survive_cal_lhfind( SurviveCalData * cd )
 {
-	struct SurviveContext * ctx = cd->ctx;
+	SurviveContext * ctx = cd->ctx;
 	int cycle, i;
 	int lh = 0;
 	FLT dx, dy, dz;
@@ -137,8 +137,8 @@ int survive_cal_lhfind( struct SurviveCalData * cd )
 		}
 
 		cd->ctx->bsd[lh].PositionSet = 1;
-		copy3d( cd->ctx->bsd[lh].Position, LighthousePos );
-		quatcopy( cd->ctx->bsd[lh].Quaternion, LighthouseQuat );
+		copy3d( cd->ctx->bsd[lh].Pose.Pos, LighthousePos );
+		quatcopy( cd->ctx->bsd[lh].Pose.Rot, LighthouseQuat );
 	}
 
 	return 0; //Return 0 if success.
@@ -149,14 +149,14 @@ int survive_cal_lhfind( struct SurviveCalData * cd )
 
 
 
-static FLT RunOpti( struct SurviveCalData * cd, int lh, int print, FLT * LighthousePos, FLT * LighthouseQuat )
+static FLT RunOpti( SurviveCalData * cd, int lh, int print, FLT * LighthousePos, FLT * LighthouseQuat )
 {
 	int i, p;
 	FLT UsToTarget[3];
 	FLT LastUsToTarget[3];
 	FLT mux = .9;
 	quatsetnone( LighthouseQuat );
-	struct SurviveObject * hmd = cd->hmd;
+	SurviveObject * hmd = cd->hmd;
 	FLT * hmd_points  = hmd->sensor_locations;
 	FLT * hmd_normals = hmd->sensor_normals;
 
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);
diff --git a/src/survive_config.h b/src/survive_config.h
index 234db68..cd16c76 100644
--- a/src/survive_config.h
+++ b/src/survive_config.h
@@ -40,7 +40,7 @@ void config_init();
 //void config_open(const char* path, const char* mode);
 void config_read(const char* path);
 //void config_write_lighthouse(struct BaseStationData* bsd, uint8_t length);
-void config_set_lighthouse(struct BaseStationData* bsd, uint8_t idx);
+void config_set_lighthouse(BaseStationData* bsd, uint8_t idx);
 
 void config_save(const char* path);
 const FLT config_set_float(config_group *cg, const char *tag, const FLT value);
@@ -52,4 +52,4 @@ uint16_t config_read_float_array(config_group *cg, const char *tag, FLT** values
 uint32_t config_read_uint32(config_group *cg, const char *tag, const uint32_t def);
 const char* config_read_str(config_group *cg, const char *tag, const char *def);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/survive_data.c b/src/survive_data.c
index ac640c6..63cc5c2 100644
--- a/src/survive_data.c
+++ b/src/survive_data.c
@@ -6,9 +6,9 @@
 #include <string.h>
 
 //This is the disambiguator function, for taking light timing and figuring out place-in-sweep for a given photodiode.
-void handle_lightcap( struct SurviveObject * so, struct LightcapElement * le )
+void handle_lightcap( SurviveObject * so, LightcapElement * le )
 {
-	struct SurviveContext * ctx = so->ctx;
+	SurviveContext * ctx = so->ctx;
 	//int32_t deltat = (uint32_t)le->timestamp - (uint32_t)so->last_master_time;
 
 	//if( so->codename[0] != 'H' )
diff --git a/src/survive_internal.h b/src/survive_internal.h
index 9d04d93..83a429c 100644
--- a/src/survive_internal.h
+++ b/src/survive_internal.h
@@ -29,20 +29,20 @@
 
 
 struct SurviveContext;
-struct SurviveUSBInterface;
+struct SurvivecalData;
 
 typedef int (*DeviceDriverCb)( struct SurviveContext * ctx, void * driver );
 typedef int (*DeviceDriverMagicCb)( struct SurviveContext * ctx, void * driver, int magic_code, void * data, int datalen );
 
 //This is defined in survive.h
-struct SurviveObject;
-struct SurviveCalData;
+typedef struct SurviveObject SurviveObject;
+typedef struct SurviveCalData SurviveCalData;
 
-struct BaseStationData
+typedef struct
 {
 	uint8_t PositionSet:1;
-	FLT Position[3];
-	FLT Quaternion[4];
+
+	SurvivePose Pose;
 
 	uint8_t OOTXSet:1;
 	uint32_t BaseStationID;
@@ -51,7 +51,7 @@ struct BaseStationData
 	FLT fcalcurve[2];
 	FLT fcalgibpha[2];
 	FLT fcalgibmag[2];
-};
+} BaseStationData;
 
 struct SurviveContext
 {
@@ -62,11 +62,11 @@ struct SurviveContext
 	angle_process_func angleproc;
 
 	//Calibration data:
-	struct BaseStationData bsd[NUM_LIGHTHOUSES];
+	BaseStationData bsd[NUM_LIGHTHOUSES];
 
-	struct SurviveCalData * calptr; //If and only if the calibration subsystem is attached.
+	SurviveCalData * calptr; //If and only if the calibration subsystem is attached.
 
-	struct SurviveObject ** objs;
+	SurviveObject ** objs;
 	int objs_ct;
 
 	void ** drivers;
@@ -76,25 +76,21 @@ struct SurviveContext
 	int driver_ct;
 };
 
-int survive_add_object( struct SurviveContext * ctx, struct SurviveObject * obj );
+int survive_add_object( SurviveContext * ctx, SurviveObject * obj );
 
-void survive_add_driver( struct SurviveContext * ctx, void * payload, DeviceDriverCb poll, DeviceDriverCb close, DeviceDriverMagicCb magic );
+void survive_add_driver( SurviveContext * ctx, void * payload, DeviceDriverCb poll, DeviceDriverCb close, DeviceDriverMagicCb magic );
 
 //For lightcap, etc.  Don't change this structure at all.  Regular vive is dependent on it being exactly as-is.
-struct LightcapElement
+typedef struct
 {
 	uint8_t sensor_id;
 	uint8_t type;
 	uint16_t length;
 	uint32_t timestamp;
-} __attribute__((packed));
+} __attribute__((packed))  LightcapElement;
 
 //This is the disambiguator function, for taking light timing and figuring out place-in-sweep for a given photodiode.
-void handle_lightcap( struct SurviveObject * so, struct LightcapElement * le );
-
-
-//Accept Data from backend.
-void survive_data_cb( struct SurviveUSBInterface * si );
+void handle_lightcap( SurviveObject * so, LightcapElement * le );
 
 
 #endif
diff --git a/src/survive_process.c b/src/survive_process.c
index 75453da..edabfff 100644
--- a/src/survive_process.c
+++ b/src/survive_process.c
@@ -6,9 +6,9 @@
 //XXX TODO: Once data is avialble in the context, use the stuff here to handle converting from time codes to
 //proper angles, then from there perform the rest of the solution. 
 
-void survive_default_light_process( struct SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length  )
+void survive_default_light_process( SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length  )
 {
-	struct SurviveContext * ctx = so->ctx;
+	SurviveContext * ctx = so->ctx;
 	int base_station = acode >> 2;
 	int axis = acode & 1;
 
@@ -25,7 +25,7 @@ void survive_default_light_process( struct SurviveObject * so, int sensor_id, in
 
 	//Need to now do angle correction.
 #if 1
-	struct BaseStationData * bsd = &ctx->bsd[base_station];
+	BaseStationData * bsd = &ctx->bsd[base_station];
 
 	//XXX TODO: This seriously needs to be worked on.  See: https://github.com/cnlohr/libsurvive/issues/18
 	angle += bsd->fcalphase[axis];
@@ -39,9 +39,9 @@ void survive_default_light_process( struct SurviveObject * so, int sensor_id, in
 }
 
 
-void survive_default_angle_process( struct SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle )
+void survive_default_angle_process( SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle )
 {
-	struct SurviveContext * ctx = so->ctx;
+	SurviveContext * ctx = so->ctx;
 	if( ctx->calptr )
 	{
 		survive_cal_angle( so, sensor_id, acode, timecode, length, angle );
@@ -51,7 +51,7 @@ void survive_default_angle_process( struct SurviveObject * so, int sensor_id, in
 }	
 
 
-void survive_default_imu_process( struct SurviveObject * so, int16_t * accelgyro, uint32_t timecode, int id )
+void survive_default_imu_process( SurviveObject * so, int16_t * accelgyro, uint32_t timecode, int id )
 {
 	//TODO: Writeme!
 }
diff --git a/src/survive_vive.c b/src/survive_vive.c
index 47886c9..6be5114 100644
--- a/src/survive_vive.c
+++ b/src/survive_vive.c
@@ -24,13 +24,6 @@
 
 struct SurviveViveData;
 
-//USB Subsystem 
-void survive_usb_close( struct SurviveContext * t );
-int survive_usb_init( struct SurviveViveData * sv, struct SurviveObject * hmd, struct SurviveObject *wm0, struct SurviveObject * wm1 );
-int survive_usb_poll( struct SurviveContext * ctx );
-int survive_get_config( char ** config, struct SurviveViveData * ctx, int devno, int interface, int send_extra_magic );
-
-
 const short vidpids[] = {
 	0x0bb4, 0x2c87, 0, //The main HTC HMD device
 	0x28de, 0x2000, 0, //Valve lighthouse
@@ -60,15 +53,18 @@ const char * devnames[] = {
 #define USB_IF_LIGHTCAP		4
 #define MAX_INTERFACES				5
 
-typedef void (*usb_callback)( struct SurviveUSBInterface * ti );
+typedef struct SurviveUSBInterface SurviveUSBInterface;
+typedef struct SurviveViveData SurviveViveData;
+
+typedef void (*usb_callback)( SurviveUSBInterface * ti );
 
 struct SurviveUSBInterface
 {
-	struct SurviveViveData * sv;
-	struct SurviveContext * ctx;
+	SurviveViveData * sv;
+	SurviveContext * ctx;
 
 	struct libusb_transfer * transfer;
-	struct SurviveObject * assoc_obj;
+	SurviveObject * assoc_obj;
 	int actual_len;
 	uint8_t buffer[INTBUFFSIZE];
 	usb_callback cb;
@@ -78,16 +74,24 @@ struct SurviveUSBInterface
 
 struct SurviveViveData
 {
-	struct SurviveContext * ctx;
+	SurviveContext * ctx;
 
 	//XXX TODO: UN-STATICIFY THIS.
-	struct SurviveUSBInterface uiface[MAX_INTERFACES];
+	SurviveUSBInterface uiface[MAX_INTERFACES];
 	//USB Subsystem
 	struct libusb_context* usbctx;
 	struct libusb_device_handle * udev[MAX_USB_DEVS];
 
 };
 
+void survive_data_cb( SurviveUSBInterface * si );
+
+//USB Subsystem 
+void survive_usb_close( SurviveContext * t );
+int survive_usb_init( SurviveViveData * sv, SurviveObject * hmd, SurviveObject *wm0, SurviveObject * wm1 );
+int survive_usb_poll( SurviveContext * ctx );
+int survive_get_config( char ** config, SurviveViveData * ctx, int devno, int interface, int send_extra_magic );
+
 
 
 
@@ -115,10 +119,10 @@ static void handle_transfer(struct libusb_transfer* transfer)
 
 
 
-static int AttachInterface( struct SurviveViveData * sv, struct SurviveObject * assocobj, int which_interface_am_i, libusb_device_handle * devh, int endpoint, usb_callback cb, const char * hname )
+static int AttachInterface( SurviveViveData * sv, SurviveObject * assocobj, int which_interface_am_i, libusb_device_handle * devh, int endpoint, usb_callback cb, const char * hname )
 {
-	struct SurviveContext * ctx = sv->ctx;
-	struct SurviveUSBInterface * iface = &sv->uiface[which_interface_am_i];
+	SurviveContext * ctx = sv->ctx;
+	SurviveUSBInterface * iface = &sv->uiface[which_interface_am_i];
 	iface->ctx = ctx;
 	iface->sv = sv;
 	iface->which_interface_am_i = which_interface_am_i;
@@ -680,7 +684,7 @@ static void handle_watchman( struct SurviveObject * w, uint8_t * readdata )
 		}
 
 
-		struct LightcapElement les[10];
+		LightcapElement les[10];
 		int lese = 0; //les's end
 
 		//Second, go through all LEDs and extract the lightevent from them. 
@@ -711,7 +715,7 @@ static void handle_watchman( struct SurviveObject * w, uint8_t * readdata )
 				//reverse sorted, but that is to minimize operations.  To read it
 				//in sorted order simply read it back backwards.
 				//Use insertion sort, since we should most of the time, be in order.
-				struct LightcapElement * le = &les[lese++];
+				LightcapElement * le = &les[lese++];
 				le->sensor_id = led;
 				le->type = 0xfe;
 
@@ -725,7 +729,7 @@ static void handle_watchman( struct SurviveObject * w, uint8_t * readdata )
 				int swap = lese-2;
 				while( swap >= 0 && les[swap].timestamp < les[swap+1].timestamp )
 				{
-					struct LightcapElement l;
+					LightcapElement l;
 					memcpy( &l, &les[swap], sizeof( l ) );
 					memcpy( &les[swap], &les[swap+1], sizeof( l ) );
 					memcpy( &les[swap+1], &l, sizeof( l ) );
@@ -744,17 +748,17 @@ static void handle_watchman( struct SurviveObject * w, uint8_t * readdata )
 		return;
 	end:
 		{
-			struct SurviveContext * ctx = w->ctx;
+			SurviveContext * ctx = w->ctx;
 			SV_INFO( "Light decoding fault: %d\n", fault );
 		}
 	}
 }
 
 
-void survive_data_cb( struct SurviveUSBInterface * si )
+void survive_data_cb( SurviveUSBInterface * si )
 {
 	int size = si->actual_len;
-	struct SurviveContext * ctx = si->ctx;
+	SurviveContext * ctx = si->ctx;
 #if 0
 	int i;
 	printf( "%16s: %d: ", si->hname, len );
@@ -767,7 +771,7 @@ void survive_data_cb( struct SurviveUSBInterface * si )
 #endif 
 
 	int iface = si->which_interface_am_i;
-	struct SurviveObject * obj = si->assoc_obj;
+	SurviveObject * obj = si->assoc_obj;
 	uint8_t * readdata = si->buffer;
 
 	int id = POP1;
@@ -818,7 +822,7 @@ void survive_data_cb( struct SurviveUSBInterface * si )
 	case USB_IF_WATCHMAN1:
 	case USB_IF_WATCHMAN2:
 	{
-		struct SurviveObject * w = obj;
+		SurviveObject * w = obj;
 		if( id == 35 )
 		{
 			handle_watchman( w, readdata);
@@ -844,7 +848,7 @@ void survive_data_cb( struct SurviveUSBInterface * si )
 		int i;
 		for( i = 0; i < 7; i++ )
 		{
-			handle_lightcap( obj, (struct LightcapElement*)&readdata[i*8] );
+			handle_lightcap( obj, (LightcapElement*)&readdata[i*8] );
 		}
 		break;
 	}
@@ -875,7 +879,7 @@ static int jsoneq(const char *json, jsmntok_t *tok, const char *s) {
 }
 
 
-static int ParsePoints( struct SurviveContext * ctx, struct SurviveObject * so, char * ct0conf, FLT ** floats_out, jsmntok_t * t, int i )
+static int ParsePoints( SurviveContext * ctx, SurviveObject * so, char * ct0conf, FLT ** floats_out, jsmntok_t * t, int i )
 {
 	int k;
 	int pts = t[i+1].size;
@@ -914,9 +918,9 @@ static int ParsePoints( struct SurviveContext * ctx, struct SurviveObject * so,
 	return 0;
 }
 
-static int LoadConfig( struct SurviveViveData * sv, struct SurviveObject * so, int devno, int iface, int extra_magic )
+static int LoadConfig( SurviveViveData * sv, SurviveObject * so, int devno, int iface, int extra_magic )
 {
-	struct SurviveContext * ctx = sv->ctx;
+	SurviveContext * ctx = sv->ctx;
 	char * ct0conf = 0;
 	int len = survive_get_config( &ct0conf, sv, devno, iface, extra_magic );
 
@@ -1002,21 +1006,21 @@ static int LoadConfig( struct SurviveViveData * sv, struct SurviveObject * so, i
 }
 
 
-int survive_vive_close( struct SurviveContext * ctx, void * driver )
+int survive_vive_close( SurviveContext * ctx, void * driver )
 {
-	struct SurviveViveData * sv = driver;
+	SurviveViveData * sv = driver;
  
 	survive_vive_usb_close( sv );
 }
 
 
-int DriverRegHTCVive( struct SurviveContext * ctx )
+int DriverRegHTCVive( SurviveContext * ctx )
 {
 	int i, r;
-	struct SurviveObject * hmd = calloc( 1, sizeof( struct SurviveObject ) );
-	struct SurviveObject * wm0 = calloc( 1, sizeof( struct SurviveObject ) );
-	struct SurviveObject * wm1 = calloc( 1, sizeof( struct SurviveObject ) );
-	struct SurviveViveData * sv = calloc( 1, sizeof( struct SurviveViveData ) );
+	SurviveObject * hmd = calloc( 1, sizeof( SurviveObject ) );
+	SurviveObject * wm0 = calloc( 1, sizeof( SurviveObject ) );
+	SurviveObject * wm1 = calloc( 1, sizeof( SurviveObject ) );
+	SurviveViveData * sv = calloc( 1, sizeof( SurviveViveData ) );
 
 	sv->ctx = ctx;
 
-- 
cgit v1.3.1