From 35ae82fff78557083febfa23044a5c1ba7a71b47 Mon Sep 17 00:00:00 2001 From: Jacob Alexander Date: Mon, 3 Feb 2014 00:41:57 -0800 Subject: [PATCH] Adding iGaging support for reading values as mm, um and nm. - Conversion factor "should" be ok, will require proper verification --- Debug/print/print.c | 33 ++++++++++ Debug/print/print.h | 1 + main.c | 156 +++++++++++++++++++++++--------------------- 3 files changed, 115 insertions(+), 75 deletions(-) diff --git a/Debug/print/print.c b/Debug/print/print.c index 5fcb97f..d5eb3fe 100644 --- 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 bf9aacd..e2498c4 100644 --- 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 85bce30..b6eb0e5 100644 --- 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 ); + } }