integrate josh's new work. It works! #19 is just about solved!

1 files changed, 153 insertions, 60 deletions

diff --git a/src/ootx_decoder.c b/src/ootx_decoder.c
index b8746bc..b1815d7 100644
--- a/src/ootx_decoder.c
+++ b/src/ootx_decoder.c
@@ -1,4 +1,4 @@
-// (C) 2016 Joshua Allen, MIT/x11 License.
+// (C) 2017 Joshua Allen, MIT/x11 License.
 //
 //All MIT/x11 Licensed Code in this file may be relicensed freely under the GPL or LGPL licenses.
 
@@ -6,15 +6,19 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
+#include <zlib.h>
 #include <assert.h>
 #include "ootx_decoder.h"
-#include <crc32.h>
+//#include "crc32.h"
 
 //char* fmt_str = "L Y HMD %d 5 1 206230 %d\n";
 
+#define MAX_BUFF_SIZE 64
 
-void (*ootx_packet_clbk)(ootx_decoder_context *ctx, ootx_packet* packet) = NULL;
+void (*ootx_packet_clbk)(ootx_decoder_context * ctx, ootx_packet* packet) = NULL;
+void (*ootx_bad_crc_clbk)(ootx_decoder_context * ctx, ootx_packet* packet, uint32_t crc) = NULL;
+
+void ootx_pump_bit(ootx_decoder_context *ctx, uint8_t dbit);
 
 void ootx_init_decoder_context(ootx_decoder_context *ctx) {
 	ctx->buf_offset = 0;
@@ -24,46 +28,28 @@ void ootx_init_decoder_context(ootx_decoder_context *ctx) {
 	ctx->bits_processed = 0;
 	ctx->found_preamble = 0;
 
-	memset( ctx->buffer, 0, sizeof( ctx->buffer ) );
+	ctx->buffer = (uint8_t*)malloc(MAX_BUFF_SIZE);
 	ctx->payload_size = (uint16_t*)ctx->buffer;
 	*(ctx->payload_size) = 0;
 }
-/*
-void ootx_init_buffer() {
-	buffer = (uint8_t*)malloc(MAX_BUFF_SIZE);
-	payload_size = (uint16_t*)buffer;
-	*payload_size = 0;
-}
-*/
-
-/*
-	how to decode pulses
-	ticks>2000 && delta>100000== master lighthouse
-	ticks>2000 && delta>10000 == slave lighthouse
-*/
-
-int8_t ootx_decode_lighthouse_number(uint8_t last_num, uint32_t ticks, int32_t delta) {
-	if (ticks<2000) return -1; //sweep
-	if ((ticks > 2000) & (delta>100000)) return 0; //master
-	if ((ticks > 2000) & (delta>10000)) return last_num+1; //a slave
-	return -1;
-}
 
-/*
-uint8_t ootx_decode_bit(uint32_t ticks) {
-	ticks = ((ticks/500)*500)+500;
-
-	ticks-=3000;
-	if (ticks>=2000) { ticks-=2000; }
-	if (ticks>=1000)  { return 0xFF; }
+void ootx_free_decoder_context(ootx_decoder_context *ctx) {
+	free(ctx->buffer);
+	ctx->buffer = NULL;
+	ctx->payload_size = NULL;
+}
 
-	return 0x00;
-}*/
+uint8_t ootx_decode_bit(uint32_t length) {
+	uint8_t t = (length - 2750) / 500; //why 2750?
+//	return ((t & 0x02)>0)?0xFF:0x00; //easier if we need to bitshift right
+	return ((t & 0x02)>>1);
+}
 
 uint8_t ootx_detect_preamble(ootx_decoder_context *ctx, uint8_t dbit) {
 	ctx->preamble <<= 1;
-	ctx->preamble |= (0x01 & dbit);
-	if ((ctx->preamble & 0x0001ffff) == 0x01) return 1;
+//	ctx->preamble |= (0x01 & dbit);
+	ctx->preamble |= dbit;
+	if ((ctx->preamble & 0x0003ffff) == 0x00000001) return 1;
 	return 0;
 }
 
@@ -80,7 +66,7 @@ void ootx_inc_buffer_offset(ootx_decoder_context *ctx) {
 //	assert(ctx->buf_offset<MAX_BUFF_SIZE);
 
 	/* the buffer is going to overflow, wrap the buffer and don't write more data until the preamble is found again */
-	if(ctx->buf_offset>=MAX_OOTX_BUFF_SIZE) {
+	if(ctx->buf_offset>=MAX_BUFF_SIZE) {
 		ctx->buf_offset = 0;
 		ctx->found_preamble = 0;
 	}
@@ -90,9 +76,11 @@ void ootx_inc_buffer_offset(ootx_decoder_context *ctx) {
 
 void ootx_write_to_buffer(ootx_decoder_context *ctx, uint8_t dbit) {
 	uint8_t *current_byte = ctx->buffer + ctx->buf_offset;
-//	printf("%d\n", dbit);
-	*current_byte >>= 1;
-	*current_byte |= (0x80 & dbit);
+
+	*current_byte <<= 1;
+//	*current_byte |= (0x01 & dbit);
+	*current_byte |= dbit;
+
 	++(ctx->bits_written);
 	if (ctx->bits_written>7) {
 		ctx->bits_written=0;
@@ -101,17 +89,20 @@ void ootx_write_to_buffer(ootx_decoder_context *ctx, uint8_t dbit) {
 	}
 }
 
-void ootx_process_bit(ootx_decoder_context *ctx, uint8_t dbit) {
-	//uint8_t dbit = ootx_decode_bit(length);
-	++(ctx->bits_processed);
+uint8_t ootx_process_bit(ootx_decoder_context *ctx, uint32_t length) {
+	uint8_t dbit = ootx_decode_bit(length);
+	ootx_pump_bit( ctx, dbit );
+	return dbit;
+}
 
-//	printf("z %d %d\n", bits_processed,dbit);
-//	printf("d %d\n", bits_processed,dbit);
+void ootx_pump_bit(ootx_decoder_context *ctx, uint8_t dbit) {
+//	uint8_t dbit = ootx_decode_bit(length);
+	++(ctx->bits_processed);
 
 	if ( ootx_detect_preamble(ctx, dbit) ) {
 		/*	data stream can start over at any time so we must
 			always look for preamble bits */
-		printf("Preamble found\n");
+		//printf("Preamble found\n");
 		ootx_reset_buffer(ctx);
 		ctx->bits_processed = 0;
 		ctx->found_preamble = 1;
@@ -121,7 +112,7 @@ void ootx_process_bit(ootx_decoder_context *ctx, uint8_t dbit) {
 //		printf("drop %d\n", dbit);
 		if( !dbit )
 		{
-			printf( "Sync bit missing\n" );
+			printf("Bad sync bit\n");
 			ootx_reset_buffer(ctx);
 		}
 		ctx->bits_processed = 0;
@@ -134,30 +125,132 @@ void ootx_process_bit(ootx_decoder_context *ctx, uint8_t dbit) {
 		*/
 
 		ootx_write_to_buffer(ctx, dbit);
-printf( "%d / %d -> ", ctx->buf_offset, *ctx->payload_size );
-int k;
-for( k = 0; k < 32; k++ )
-{
-	printf( "%02x ", ctx->buffer[k] );
-}
-printf( "\n" );
-		if (ctx->buf_offset >= (*(ctx->payload_size)+6)) {
+
+		uint16_t padded_length = *(ctx->payload_size);
+		padded_length += (padded_length&0x01); //extra null byte if odd
+
+/*		int k;
+		printf( ":" );
+		for( k = 0; k < 36; k++ )
+		{
+			printf( "%02x ", ctx->buffer[k] );
+		}
+		printf( "\n" );*/
+
+		if (ctx->buf_offset >= (padded_length+6)) {
 			/*	once we have a complete ootx packet, send it out in the callback */
 			ootx_packet op;
 
 			op.length = *(ctx->payload_size);
 			op.data = ctx->buffer+2;
-			op.crc32 = *(uint32_t*)(ctx->buffer+2+op.length);
+			op.crc32 = *(uint32_t*)(op.data+padded_length);
 
-			uint32_t crc = crc32(0xffffffff,op.data,op.length);
+			uint32_t crc = crc32( 0L, Z_NULL, 0 );
+			crc = crc32( crc, op.data,op.length);
 
 			if (crc != op.crc32) {
-				printf("CRC mismatch\n");
+				if (ootx_bad_crc_clbk != NULL) ootx_bad_crc_clbk(ctx, &op,crc);
+			}
+			else if (ootx_packet_clbk != NULL) {
+				ootx_packet_clbk(ctx,&op);
 			}
-
-			if ((crc == op.crc32) && ootx_packet_clbk) ootx_packet_clbk(ctx, &op);
 
 			ootx_reset_buffer(ctx);
 		}
 	}
 }
+
+uint8_t* get_ptr(uint8_t* data, uint8_t bytes, uint16_t* idx) {
+	uint8_t* x = data + *idx;
+	*idx += bytes;
+	return x;
+}
+
+float _half_to_float(uint8_t* data) {
+	//this will not handle infinity, NaN, or denormalized floats
+
+	uint16_t x = *(uint16_t*)data;
+	float f = 0;
+
+	uint32_t *ftmp = (uint32_t*)&f; //use the allocated floating point memory
+
+	if ((x & 0x7FFF) == 0) return f; //zero
+
+	//sign
+	*ftmp = x & 0x8000;
+	*ftmp <<= 16;
+
+	*ftmp += ((((uint32_t)(x & 0x7fff)) + 0x1c000) << 13);
+
+	return f;
+}
+
+void init_lighthouse_info_v6(lighthouse_info_v6* lhi, uint8_t* data) {
+	uint16_t idx = 0;
+	/*
+	uint16_t fw_version;//Firmware version (bit 15..6), protocol version (bit 5..0)
+	uint32_t id; //Unique identifier of the base station
+	float fcal_0_phase; //"phase" for rotor 0
+	float fcal_1_phase; //"phase" for rotor 1
+	float fcal_0_tilt; //"tilt" for rotor 0
+	float fcal_1_tilt; //"tilt" for rotor 1
+	uint8_t sys_unlock_count; //Lowest 8 bits of the rotor desynchronization counter
+	uint8_t hw_version; //Hardware version
+	float fcal_0_curve; //"curve" for rotor 0
+	float fcal_1_curve; //"curve" for rotor 1
+	int8_t accel_dir_x; //"orientation vector"
+	int8_t accel_dir_y; //"orientation vector"
+	int8_t accel_dir_z; //"orientation vector"
+	float fcal_0_gibphase; //"gibbous phase" for rotor 0 (normalized angle)
+	float fcal_1_gibphase; //"gibbous phase" for rotor 1 (normalized angle)
+	float fcal_0_gibmag; //"gibbous magnitude" for rotor 0
+	float fcal_1_gibmag; //"gibbous magnitude" for rotor 1
+	uint8_t mode_current; //Currently selected mode (default: 0=A, 1=B, 2=C)
+	uint8_t sys_faults; //"fault detect flags" (should be 0)
+	*/
+
+	lhi->fw_version = *(uint16_t*)get_ptr(data,sizeof(uint16_t),&idx);
+	lhi->id = *(uint32_t*)get_ptr(data,sizeof(uint32_t),&idx);
+	lhi->fcal_0_phase = _half_to_float( get_ptr(data,sizeof(uint16_t),&idx) );
+	lhi->fcal_1_phase = _half_to_float( get_ptr(data,sizeof(uint16_t),&idx) );
+	lhi->fcal_0_tilt = _half_to_float( get_ptr(data,sizeof(uint16_t),&idx) );
+	lhi->fcal_1_tilt = _half_to_float( get_ptr(data,sizeof(uint16_t),&idx) );
+	lhi->sys_unlock_count = *get_ptr(data,sizeof(uint8_t),&idx);
+	lhi->hw_version = *get_ptr(data,sizeof(uint8_t),&idx);
+	lhi->fcal_0_curve = _half_to_float( get_ptr(data,sizeof(uint16_t),&idx) );
+	lhi->fcal_1_curve = _half_to_float( get_ptr(data,sizeof(uint16_t),&idx) );
+	lhi->accel_dir_x = *(int8_t*)get_ptr(data,sizeof(uint8_t),&idx);
+	lhi->accel_dir_y = *(int8_t*)get_ptr(data,sizeof(uint8_t),&idx);
+	lhi->accel_dir_z = *(int8_t*)get_ptr(data,sizeof(uint8_t),&idx);
+	lhi->fcal_0_gibphase = _half_to_float( get_ptr(data,sizeof(uint16_t),&idx) );
+	lhi->fcal_1_gibphase = _half_to_float( get_ptr(data,sizeof(uint16_t),&idx) );
+	lhi->fcal_0_gibmag = _half_to_float( get_ptr(data,sizeof(uint16_t),&idx) );
+	lhi->fcal_1_gibmag = _half_to_float( get_ptr(data,sizeof(uint16_t),&idx) );
+	lhi->mode_current = *get_ptr(data,sizeof(uint8_t),&idx);
+	lhi->sys_faults = *get_ptr(data,sizeof(uint8_t),&idx);
+
+}
+
+void print_lighthouse_info_v6(lighthouse_info_v6* lhi) {
+
+	printf("\t%X\n\t%X\n\t%f\n\t%f\n\t%f\n\t%f\n\t%d\n\t%d\n\t%f\n\t%f\n\t%d\n\t%d\n\t%d\n\t%f\n\t%f\n\t%f\n\t%f\n\t%d\n\t%d\n",
+		lhi->fw_version,
+		lhi->id,
+		lhi->fcal_0_phase,
+		lhi->fcal_1_phase,
+		lhi->fcal_0_tilt,
+		lhi->fcal_1_tilt,
+		lhi->sys_unlock_count,
+		lhi->hw_version,
+		lhi->fcal_0_curve,
+		lhi->fcal_1_curve,
+		lhi->accel_dir_x,
+		lhi->accel_dir_y,
+		lhi->accel_dir_z,
+		lhi->fcal_0_gibphase,
+		lhi->fcal_1_gibphase,
+		lhi->fcal_0_gibmag,
+		lhi->fcal_1_gibmag,
+		lhi->mode_current,
+		lhi->sys_faults);
+}