Initial work for iGaging distance gauge.

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 )
 {
 }