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

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

diff --git a/Debug/print/print.c b/Debug/print/print.c
index 5fcb97f27c8989cf9aff96d199ad0e78b9ecb476..d5eb3fe53a431ed514e8cbcef8080e6e8cf0e867 100644 (file)
--- a/Debug/print/print.c
+++ b/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;
+}
+

diff --git a/Debug/print/print.h b/Debug/print/print.h
index bf9aacdb9698a6abb7dd1d3d773947695d36b4c5..e2498c40c8f17e1be08c7478d399960687850206 100644 (file)
--- a/Debug/print/print.h
+++ b/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
 

diff --git a/main.c b/main.c
index 85bce30990996dc99554e9e22003fde9d90cf4dc..b6eb0e5285c075e0802c577096075f91caa4042b 100644 (file)
--- a/main.c
+++ b/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  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
+       uint32_t high_delay = 22; // Clock high time per pulse
+       uint32_t  low_delay = 89; // 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,70 +256,85 @@ while(1)
                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");
-               }
+               distInput |= GPIOC_PDIR & (1<<1) ? (1 << bit) : 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;
+
+       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 );
+
+               // 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.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:
+               //    mm is 2 097 152                 :          0.009 921 875 000 mm : 32 bit
+               //    um is 2 097 152 000             :          9.921 875 000     um : 32 bit (ideal acc. for 32 bit)
+               //    nm is 2 097 152 000 000         :      9 921.875 000         nm : 64 bit
+               //    pm is 2 097 152 000 000 000     :  9 921 875.000             pm : 64 bit (ideal acc. for 64 bit)
+
+               // XXX Apparently shumatech was sorta wrong about the 21 bits of usage
+               // Yes there are 21 bits, but the values only go from ~338 to ~30681 which is less than 16 bits...
+               // This means that the conversion at NM can use 32 bits :D
+               // It's been noted that the multiplier should be 100.6 (and that it could vary from scale to scale)
+               uint32_t distNM = distInput * 9921;;
+               uint32_t distUM = distNM / 1000;
+               uint32_t distMM = distUM / 1000;
+
+               print("  ");
+               printInt32( distMM );
+               print(" mm  ");
+               printInt32( distUM );
+               print(" um  ");
+               printInt32( distNM );
+               print(" nm  ");
+
+               print( NL );
+
+               // Only delay if still counting
+               if ( read_count > 1 )
+                       delay( 50 );
+       }
 }