di0ib/controller
Archived
1
0
Fork 0
Code Releases Activity

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

Browse Source 
- Conversion factor "should" be ok, will require proper verification
This commit is contained in:
Jacob Alexander 2014-02-03 00:41:57 -08:00
parent 8263589e7e
commit 35ae82fff7
3 changed files with 115 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
Debug/print/print.c
View File

@ -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;
}

1
Debug/print/print.h
View File

@ -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

100
main.c
View File

@ -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,21 +256,41 @@ 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(" ");
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
// 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;
// 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)
// 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;
// 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;
@ -322,13 +329,12 @@ while(1)
printInt32( distNM );
print(" nm ");
/*
//Wait
print( NL );
delay( 7 );
distInput = 0;
// Only delay if still counting
if ( read_count > 1 )
delay( 50 );
}
*/
}