//------------------------------------------------------------------------------
static unsigned char ad7799_InitStatus;


//------------------------------------------------------------------------------
static void ad7799_Reset()
{
    for(unsigned char i = 0; i < 4; i++)
        SpiTransferByte(0xff);
}


// Helper request function
//------------------------------------------------------------------------------
static inline void ad7799_Comm(unsigned char reg, unsigned char read, unsigned char cont)
{
    SpiTransferByte((read ? 0x40 : 0x00) | (reg << 3) | (cont ? 0x04 : 0x00));
}


// Return the contents of the AD7799 register ( OFFSET or FULL-SCALE )
//------------------------------------------------------------------------------
unsigned long ad7799_Read(unsigned char reg)
{
    ad7799_Comm(reg, 1, 0);
    unsigned long val = 0;
    
    if(ad7799_InitStatus & AD7799_STATUS_IS_AD7799)
       val |= (unsigned long)SpiTransferByte() << 16;
    val |= (unsigned long)SpiTransferByte() << 8;
    val |= (unsigned long)SpiTransferByte();
    
    return val;
}


//------------------------------------------------------------------------------
unsigned char ad7799_Status()
{
    ad7799_Comm(AD7799_STATUS_REG, 1, 0);
  
    return SpiTransferByte();
}


//------------------------------------------------------------------------------
void ad7799_SetMode(unsigned char mode, unsigned char psw, unsigned char rate)
{
    ad7799_Comm(AD7799_MODE_REG, 0, 0);
    SpiTransferByte(mode << 5 | (psw ? 0x10 : 0x00));
    SpiTransferByte(rate);
}


//------------------------------------------------------------------------------
void ad7799_WriteConfig(unsigned char burnout, unsigned char unipolar, unsigned char gain,
                        unsigned char ref_det, unsigned char buf, unsigned char chan)
{
    ad7799_Comm(AD7799_CONFIG_REG, 0, 0);
    SpiTransferByte((burnout ? 0x20 : 0x00) | (unipolar ? 0x10 : 0x00) | gain);
    SpiTransferByte((ref_det ? 0x20 : 0x00) | (buf ? 0x10 : 0x00) | chan);
}


// Write value to the AD7799 register ( OFFSET or FULL-SCALE )
//------------------------------------------------------------------------------
void ad7799_Write(unsigned char reg, signed long value)
{
    ad7799_Comm(reg, 0, 0);  
  
    if(ad7799_InitStatus & AD7799_STATUS_IS_AD7799)
       SpiTransferByte(value >> 16);

    SpiTransferByte(value >> 8);    
    SpiTransferByte(value);
}

// Determine if data is ready to be read, could also be implemented by reading the status register
//------------------------------------------------------------------------------
bool ad7799_DataReady()
{
    return !(PIND & (1 << RDY));      //DD_MISO
}


// Request a read from the data register
//------------------------------------------------------------------------------
void ad7799_RequestData(unsigned char continuous)
{
    ad7799_Comm(AD7799_DATA_REG, 1, continuous);
}


// Read from data register, it should be previously requested from ad7799_request_data, the value is signed
//------------------------------------------------------------------------------
unsigned long ad7799_ReadData()
{
    unsigned long val = 0;

    if(ad7799_InitStatus & AD7799_STATUS_IS_AD7799)
    {
        val = SpiTransferByte();
        val <<= 8;
    }

    val |= SpiTransferByte();
    val <<= 8;
    val |= SpiTransferByte();

    return val;
}

(AdcValue - STEPS_B) * VREF / 128 / STEPS_B

(AdcValue - STEPS_B)/(2^(30))* VREF

#define STEPS_B 8388608LL
long long Vtc(long long AdcValue)
{
return ((long long)(AdcValue - STEPS_B)*5000000LL>>31LL);
}

enum { AD7799_1_GAIN, AD7799_2_GAIN, AD7799_4_GAIN, AD7799_8_GAIN,
       AD7799_16_GAIN, AD7799_32_GAIN, AD7799_64_GAIN, AD7799_128_GAIN };

#define BITS            24

int Vtc(long AdcValue)
{
   return (AdcValue - STEPS_B) * VREF >> (AD7799_128_GAIN + BITS - 1);  //30;  
}