Datasheet

LTC2480
39
2480fd
/*** read_LTC2480() ************************************************************
This is the function that actually does all the work of talking to the LTC2480.
The spi_read() function performs an 8 bit bidirectional transfer on the SPI bus.
Data changes state on falling clock edges and is valid on rising edges, as
determined by the setup_spi() line in the initialize() function.
A good starting point when porting to other processors is to write your own
spi_write function. Note that each processor has its own way of conguring
the SPI port, and different compilers may or may not have built-in functions
for the SPI port. Also, since the state of the LTC2480’s SDO line indicates
when a conversion is complete you need to be able to read the state of this line
through the processor’s serial data input. Most processors will let you read
this pin as if it were a general purpose I/O line, but there may be some that
don’t.
When in doubt, you can always write a “bit bang” function for troubleshooting
purposes.
The “fourbytes” structure allows byte access to the 32 bit return value:
struct fourbytes // Dene structure of four consecutive bytes
{ // To allow byte access to a 32 bit int or oat.
int8 te0; //
int8 te1; // The make32() function in this compiler will
int8 te2; // also work, but a union of 4 bytes and a 32 bit int
int8 te3; // is probably more portable.
};
Also note that the lower 4 bits are the conguration word from the previous
conversion. The 4 LSBs are cleared so that
they don’t affect any subsequent mathematical operations. While you can do a
right shift by 4, there is no point if you are going to convert to oating point
numbers - just adjust your scaling constants appropriately.
*******************************************************************************/
signed int32 read_LTC2480(char cong)
{
union // adc_code.bits32 all 32 bits
{ // adc_code.by.te0 byte 0
signed int32 bits32; // adc_code.by.te1 byte 1
struct fourbytes by; // adc_code.by.te2 byte 2
} adc_code; // adc_code.by.te3 byte 3
output_low(CS); // Enable LTC2480 SPI interface
while(input(PIN_C4)) {} // Wait for end of conversion. The longest
// you will ever wait is one whole conversion period
// Now is the time to switch any multiplexers because the conversion is nished
// and you have the whole data output time for things to settle.
adc_code.by.te3 = 0; // Set upper byte to zero.
adc_code.by.te2 = spi_read(cong); // Read rst byte, send cong byte
adc_code.by.te1 = spi_read(0); // Read 2nd byte, send speed bit
adc_code.by.te0 = spi_read(0); // Read 3rd byte. ‘0’ argument is necessary
// to act as SPI master!! (compiler
// and processor specic.)
output_high(CS); // Disable LTC2480 SPI interface
// Clear conguration bits and subtract offset. This results in
// a 2’s complement 32 bit integer with the LTC2480’s MSB in the 2^20 position
adc_code.by.te0 = adc_code.by.te0 & 0xF0;
adc_code.bits32 = adc_code.bits32 - 0x00200000;
return adc_code.bits32;
} // End of read_LTC2480()
applicaTions inForMaTion