Initial work for iGaging distance gauge.

Debug/print/print.c

@@ -116,6 +116,18 @@ void printInt16( uint16_t in )
 	dPrintStr( tmpStr );
 }
 
+void printInt32( uint32_t in )
+{
+	// Max number of characters is 10 + 1 for null
+	char tmpStr[11];
+
+	// Convert number
+	int32ToStr( in, tmpStr );
+
+	// Print number
+	dPrintStr( tmpStr );
+}
+
 void printHex_op( uint16_t in, uint8_t op )
 {
 	// With an op of 1, the max number of characters is 6 + 1 for null
@@ -175,6 +187,27 @@ void int16ToStr( uint16_t in, char* out )
 }
 
 
+void int32ToStr( uint32_t in, char* out )
+{
+	// Position and sign containers
+	uint32_t pos;
+	pos = 0;
+
+	// Evaluate through digits as decimal
+	do
+	{
+		out[pos++] = in % 10 + '0';
+	}
+	while ( (in /= 10) > 0 );
+
+	// Append null
+	out[pos] = '\0';
+
+	// Reverse the string to the correct order
+	revsStr(out);
+}
+
+
 void hexToStr_op( uint16_t in, char* out, uint8_t op )
 {
 	// Position container

Debug/print/print.h

@@ -98,6 +98,7 @@ void usb_debug_putstrs( char* first, ... );
 
 void printInt8  ( uint8_t  in );
 void printInt16 ( uint16_t in );
+void printInt32 ( uint32_t in );
 void printHex_op( uint16_t in, uint8_t op );
 
 
@@ -106,6 +107,7 @@ void printHex_op( uint16_t in, uint8_t op );
 
 void int8ToStr  ( uint8_t  in, char*  out );
 void int16ToStr ( uint16_t in, char*  out );
+void int32ToStr ( uint32_t in, char*  out );
 void hexToStr_op( uint16_t in, char*  out, uint8_t op );
 void revsStr    ( char*  in );
 uint16_t lenStr ( char*  in );

main.c

@@ -51,6 +51,7 @@
 
 // ----- Function Declarations -----
 
+void cliFunc_distRead    ( char* args );
 void cliFunc_free        ( char* args );
 void cliFunc_gaugeHelp   ( char* args );
 void cliFunc_single      ( char* args );
@@ -225,6 +226,112 @@ void pit0_isr(void)
 
 // ----- CLI Command Functions -----
 
+void cliFunc_distRead( char* args )
+{
+	// Prepare to print output
+	print( NL );
+	info_msg("Distance: ");
+
+	// Data
+	uint32_t distInput = 0;
+
+	// Setup distance read parameters for iGaging Distance Scale
+	//       freq = 9kHz
+	// duty_cycle = 20%
+	// high_delay = (1/freq) *       (duty_cycle/100)
+	//  low_delay = (1/freq) * ((100-duty_cycle)/100)
+	uint8_t  bits       = 21; // 21 clock pulses, for 21 bits
+	//uint32_t high_delay = 22; // Clock high time per pulse
+	//uint32_t  low_delay = 89; // Clock low  time per pulse
+	uint32_t high_delay = 40; // Clock high time per pulse
+	uint32_t  low_delay = 60; // Clock low  time per pulse
+
+	// Make sure clock is low initially
+	GPIOC_PCOR |= (1<<2); // Set Clock low
+/*
+while(1)
+{
+*/
+	// Scan each of the bits
+	for ( uint8_t bit = bits; bit > 0; bit-- )
+	{
+		// Begin clock pulse
+		GPIOC_PSOR |= (1<<2); // Set Clock high
+
+		// Delay for duty cycle
+		delayMicroseconds( high_delay );
+
+		// End clock pulse
+		GPIOC_PCOR |= (1<<2); // Set Clock low
+
+		// Read Data Bit
+		//distInput |= GPIOD_PDIR & (1<<6) ? (1 << (bit - 1)) : 0;
+		//if ( GPIOD_PDIR )
+		if ( GPIOD_PDIR & (1<<6) )
+		{
+			print("1");
+		}
+		else
+		{
+			print("0");
+		}
+
+		// Delay for duty cycle
+		delayMicroseconds( low_delay );
+	}
+	print("  ");
+
+	// Output result
+	printInt32( distInput );
+
+	// Convert to mm
+	// As per http://www.shumatech.com/web/21bit_protocol?page=0,1
+	// 21 bits is 2560 CPI (counts per inch) (C/inch)
+	// 1 inch is 25.4 mm
+	// 2560 / 25.4 = 100.7874016... CPMM (C/mm)
+	// Or
+	// 1 count is 1/2560 = 0.000390625... inches
+	// 1 count is (1/2560) * 25.4 = 0.0000153789370078740 mm = 0.0153789370078740 um = 15.3789370078740 nm
+	// Since there are 21 bits (2 097 152 positions) converting to um is possible by multiplying by 1000
+	//    which is 2 097 152 000, and within 32 bits (4 294 967 295).
+	// However, um is still not convenient, so 64 bits (18 446 744 073 709 551 615) is a more accurate alternative.
+	// For each nm there are 2 097 152 000 000 positions.
+	// And for shits:
+	//    pm is 2 097 152                 :          0.000 015 378 937 007 874 0 mm : 32 bit
+	//    pm is 2 097 152 000             :          0.015 378 937 007 874 0     um : 32 bit (ideal acc. for 32 bit)
+	//    pm is 2 097 152 000 000         :         15.378 937 007 874 0         nm : 64 bit
+	//    pm is 2 097 152 000 000 000     :     15 378.937 007 874 0             pm : 64 bit
+	//    fm is 2 097 152 000 000 000 000 : 15 378 937.007 874 0                 fm : 64 bit (ideal acc. for 64 bit)
+	//uint64_t distNM = distInput * 15;
+	//uint64_t distPM = distInput * 15378;
+	uint64_t distFM = distInput * 15378937;
+
+	// Calculate um and mm
+	//uint32_t distNM = distInput * 15; // XXX
+	//uint32_t distUM = distNM / 1000;
+	//uint32_t distMM = distNM / 1000000;
+	uint32_t distNM = distFM * 1000000;
+	uint32_t distUM = distNM / 1000;
+	uint32_t distMM = distUM / 1000;
+
+	print("  ");
+	printInt32( distMM );
+	print(" mm  ");
+	printInt32( distUM );
+	print(" um  ");
+	printInt32( distNM );
+	print(" nm");
+
+/*
+//Wait
+print(NL);
+delay( 7 );
+distInput = 0;
+}
+*/
+}
+
+
 void cliFunc_free( char* args )
 {
 }