Adding iGaging support for reading values as mm, um and nm.

- Conversion factor "should" be ok, will require proper verification

Debug/print/print.c

@@ -284,3 +284,36 @@ int16_t eqStr( char* str1, char* str2 )
 	return *--str1 == *--str2 ? -1 : *++str1;
 }
 
+int decToInt( char* in )
+{
+	// Pointers to the LSD (Least Significant Digit) and MSD
+	char* lsd = in;
+	char* msd = in;
+
+	int total = 0;
+	int sign = 1; // Default to positive
+
+	// Scan the string once to determine the length
+	while ( *lsd != '\0' )
+	{
+		// Check for positive/negative
+		switch ( *lsd++ )
+		{
+		// Fall through is intentional, only do something on negative, ignore the rest
+		// Update the MSD to remove leading spaces and signs
+		case '-': sign = -1;
+		case '+':
+		case ' ':
+			msd = lsd;
+			break;
+		}
+	}
+
+	// Rescan the string from the LSD to MSD to convert it to a decimal number
+	for ( unsigned int digit = 1; lsd > msd ; digit *= 10 )
+		total += ( (*--lsd) - '0' ) * digit;
+
+	// Propagate sign and return
+	return total * sign;
+}
+

Debug/print/print.h

@@ -112,6 +112,7 @@ void hexToStr_op( uint16_t in, char*  out, uint8_t op );
 void revsStr    ( char*  in );
 uint16_t lenStr ( char*  in );
 int16_t eqStr   ( char*  str1, char* str2 ); // Returns -1 if identical, last character of str1 comparison (0 if str1 is like str2)
+int decToInt    ( char* in ); // Returns the int representation of a string
 
 #endif
 

main.c

@@ -226,34 +226,25 @@ void pit0_isr(void)
 
 // ----- CLI Command Functions -----
 
-void cliFunc_distRead( char* args )
+uint32_t readDistanceGauge()
 {
-	// 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 high_delay = 22; // Clock high time per pulse
-	//uint32_t  low_delay = 89; // Clock low  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
+	// Data
+	uint32_t distInput = 0;
 
 	// 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-- )
+	for ( uint8_t bit = 0; bit < bits; bit++ )
 	{
 		// Begin clock pulse
 		GPIOC_PSOR |= (1<<2); // Set Clock high
@@ -265,21 +256,41 @@ while(1)
 		GPIOC_PCOR |= (1<<2); // Set Clock low
 
 		// Read Data Bit
-		//distInput |= GPIOD_PDIR & (1<<6) ? (1 << (bit - 1)) : 0;
+		distInput |= GPIOC_PDIR & (1<<1) ? (1 << bit) : 0;
-		//if ( GPIOD_PDIR )
-		if ( GPIOD_PDIR & (1<<6) )
-		{
-			print("1");
-		}
-		else
-		{
-			print("0");
-		}
 
 		// Delay for duty cycle
 		delayMicroseconds( low_delay );
 	}
-	print("  ");
+
+	return distInput;
+}
+
+void cliFunc_distRead( char* args )
+{
+	// Parse number from argument
+	//  NOTE: Only first argument is used
+	char* arg1Ptr;
+	char* arg2Ptr;
+	argumentIsolation_cli( args, &arg1Ptr, &arg2Ptr );
+
+	// Convert the argument into an int
+	int read_count = decToInt( arg1Ptr ) + 1;
+
+	// If no argument specified, default to 1 read
+	if ( *arg1Ptr == '\0' )
+	{
+		read_count = 2;
+	}
+
+	// Repeat reading as many times as specified in the argument
+	print( NL );
+	while ( --read_count > 0 )
+	{
+		// Prepare to print output
+		info_msg("Distance: ");
+
+		// Data
+		uint32_t distInput = readDistanceGauge();
 
 		// Output result
 		printInt32( distInput );
@@ -291,26 +302,22 @@ while(1)
 		// 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
+		// 1 count is (1/2560) * 25.4 = 0.00992187500000000 mm = 9.92187500000000 um = 9921.87500000000 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
+		//    mm is 2 097 152                 :          0.009 921 875 000 mm : 32 bit
-	//    pm is 2 097 152 000             :          0.015 378 937 007 874 0     um : 32 bit (ideal acc. for 32 bit)
+		//    um is 2 097 152 000             :          9.921 875 000     um : 32 bit (ideal acc. for 32 bit)
-	//    pm is 2 097 152 000 000         :         15.378 937 007 874 0         nm : 64 bit
+		//    nm is 2 097 152 000 000         :      9 921.875 000         nm : 64 bit
-	//    pm is 2 097 152 000 000 000     :     15 378.937 007 874 0             pm : 64 bit
+		//    pm is 2 097 152 000 000 000     :  9 921 875.000             pm : 64 bit (ideal acc. for 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
+		// XXX Apparently shumatech was sorta wrong about the 21 bits of usage
-	//uint32_t distNM = distInput * 15; // XXX
+		// Yes there are 21 bits, but the values only go from ~338 to ~30681 which is less than 16 bits...
-	//uint32_t distUM = distNM / 1000;
+		// This means that the conversion at NM can use 32 bits :D
-	//uint32_t distMM = distNM / 1000000;
+		// It's been noted that the multiplier should be 100.6 (and that it could vary from scale to scale)
-	uint32_t distNM = distFM * 1000000;
+		uint32_t distNM = distInput * 9921;;
 		uint32_t distUM = distNM / 1000;
 		uint32_t distMM = distUM / 1000;
 
@@ -320,15 +327,14 @@ while(1)
 		printInt32( distUM );
 		print(" um  ");
 		printInt32( distNM );
-	print(" nm");
+		print(" nm  ");
 
-/*
+		print( NL );
-//Wait
+
-print(NL);
+		// Only delay if still counting
-delay( 7 );
+		if ( read_count > 1 )
-distInput = 0;
+			delay( 50 );
-}
+	}
-*/
 }