di0ib
/
controller
Watch 1
Star 0
Fork 0
Code Releases 0 Activity
Browse Source

Initial work for iGaging distance gauge.

simple
Jacob Alexander 10 years ago
parent
f55ec0de1a
commit
cd59498972
3 changed files with 142 additions and 0 deletions
Split View Show Diff Stats
  1. 33
    0
      Debug/print/print.c
  2. 2
    0
      Debug/print/print.h
  3. 107
    0
      main.c

+ 33
- 0
Debug/print/print.c View File

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

+ 2
- 0
Debug/print/print.h View File

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

+ 107
- 0
main.c View File

@@ -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 )
{
}