Initial work for iGaging distance gauge.

diff --git a/Debug/print/print.c b/Debug/print/print.c
index 147bd97635b9305776d56254e41804280b600bfe..4f765ac1db6bcc40ca4ee9139e1b896e5751e347 100644 (file)
--- a/Debug/print/print.c
+++ b/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

diff --git a/Debug/print/print.h b/Debug/print/print.h
index c4d909237ff2bd094526fe9d129124a6a6d616d0..8a07baae1950794497bcfe02d2630edbd1846991 100644 (file)
--- a/Debug/print/print.h
+++ b/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 );

diff --git a/main.c b/main.c
index 2b45e9c97966de5992cf8ee4c9e1f7e31cfa8706..85bce30990996dc99554e9e22003fde9d90cf4dc 100644 (file)
--- a/main.c
+++ b/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 )
 {
 }