// HEADER
//----------------------

// AD7799 macro definitions
#define AD7799_CS_ACTIVE      PORTC &= ~(1 << CS)
#define AD7799_CS_INACTIVE      PORTC |= (1 << CS)

#define NMAX            3

#define AVCC            5.0         // AVCC = +5.0 V
#define VREF            2.5         // VREF = +2.5 V
#define TMP_SEN         0.01        // Temperature sensor sensitivity tmp36, V/C
#define OFFSET_VOLTAGE  0.5         // Offset voltage of TMP36 (0.5 V)

#define STEPS_U         16777216.0  // Full-Scale 2^24 for unipolar operation
#define STEPS_B         8388608.0   // Full-Scale 2^(24-1) for bipolar operation

#define TC    0
#define CJ    1

typedef struct
{
    unsigned char Channel;        // каналы
    //double TemperatureCJ;       // температура TMP36
    double TemperatureTC;         // температура термопары
    long Data[2];                 // Значения АЦП для двух каналов
}RESULT;

extern RESULT Result;

  
typedef struct
{
    int Index;                    // номер диапазона температур
    int Threshold;                // температурный порог
    int Hysteresis;               // гистерезис
    int Average;                  // усреднение
    double Offset[6];             // значения смещений для разных диапазонов температур  
    double Reference[6];          // реперные точки
}VALUE;

extern VALUE Value;

typedef struct
{
    unsigned char volatile One;     // Первое (младшее) знакоместо
    unsigned char volatile Ten;     // Второе знакоместо
    unsigned char volatile Hundred; // Третье знакоместо
    unsigned char volatile Thousand;// Четвертое (старшее) знакоместо
}DIGIT;

////////////////////////////////////////
//      SOURCE
//-----------------------------------

// AD7799 Initialization
//------------------------------------------------------------------------------
void ad7799_Init()
{
    ad7799_Reset();
    delay_ms(500);
    ad7799_InitStatus = ad7799_Status();
}

// Запуск непрерывного преобразования на AIN1
//------------------------------------------------------------------------------
void ad7799_StartMeasure()
{
    AD7799_CS_ACTIVE;
    ad7799_WriteConfig(1, 0, AD7799_128_GAIN, 1, 1, AD7799_AIN1_CHAN);     // burnout, bipolar, gain, ref_det, buf, chan
    ad7799_SetMode(AD7799_CONTINUOUS_CONVERSION_MODE, 0, AD7799_16_7_1_HZ);  // mode, psw=0(OFF), rate    
}


//------------------------------------------------------------------------------
void ad7799_Measure()
{
        Result.Data[Result.Channel] = 0;
    
        while(!ad7799_DataReady());             // Ждать окончания преобразования АЦП (RDY => 0)
        
        ad7799_RequestData(CONTINUOUS_READ);    // 1 -> Continuous Read  
        PORTD &= ~(1 << DIN);                   // Held Low in Continuous-Read mode        
        
        for(unsigned char i = 0; i < Value.Average; i++)   // (1 << NMAX)
        {
            while(!ad7799_DataReady());    // Ждать окончания преобразования АЦП (RDY => 0)
              
            Result.Data[Result.Channel] += ad7799_ReadData(); // Накапливаем результат
        }        
          
        Result.Data[Result.Channel] /= Value.Average; // >>= NMAX;    // Усреднение результата
        
        while(!ad7799_DataReady());            // Ждать окончания преобразования АЦП (RDY => 0)
              ad7799_RequestData(NOT_CONTINUOUS_READ);  // 0 -> Not Continuous Read  
              
        // Maintain multiplexing of input channels
        //if(++Result.Channel > 2)
        //   Result.Channel = 0;  
        
        switch(Result.Channel)
        {
            case AD7799_AIN1_CHAN:
                  ad7799_WriteConfig(1, 0, AD7799_128_GAIN, 1, 1, AD7799_AIN1_CHAN + Result.Channel); // burnout, bipolar, gain, ref_det, buf, chan                
                  break;
                  
            case AD7799_AIN2_CHAN:
                  ad7799_WriteConfig(1, 0, AD7799_2_GAIN, 1, 1, AD7799_AIN1_CHAN + Result.Channel);   // burnout, bipolar, gain, ref_det, buf, chan                
                  break;  
        }
}

void Initialise()
{
.....
    Result.Channel = 0;
    ad7799_Init();
    ad7799_StartMeasure();
}


void main()
{  
    Initialise();           // set up I/O registers, flags & variables

    __enable_interrupt();   // allow all enabled interrupts
        
    for(;;)
    {
        ad7799_Measure();

        Result.TemperatureTC = Vtc(Result.Data[TC]) * 1000;
    

        __sleep();    //Idle. Спать до следующего прерывания
    }
}

//  Вычисление напряжения термопары, В
//------------------------------------------------------------------------------
double Vtc(long AdcValue)
{
    return (AdcValue - STEPS_B) * VREF / 128 / STEPS_B;
}


// Timer/Counter0 Overflow ISR: Вызывается с интервалом 4 мс
// Вывод значения на индикатор и обработка нажатия кнопок.
//------------------------------------------------------------------------------
#pragma vector=TIMER0_OVF_vect
__interrupt void TIMER0_OVF_ISR()
{  
    // Динамическая индикация четырехразрядного индикатора
    switch(znak)
    {
      case 0:
        {
            int temp = (pValue == &Result.TemperatureTC)
                      ? (int)(Result.TemperatureTC * 10) : *(int*)pValue;
            
            // Преобразовать значение *pValue в BCD число:
            bin2bcd(ABS(temp));
            
            if(temp < 0)
            {
                if(temp > -10)
                {
                    Digit.Ten = MINUS;
                    Digit.Hundred = EMPTY;
                    Digit.Thousand = EMPTY;
                }
            
                else if(temp > -100)
                {
                  Digit.Hundred = MINUS;  
                  Digit.Thousand = EMPTY;
                }
                
                else if(temp > -1000)
                  Digit.Thousand = MINUS;  
            }
            else
            {
                if(temp < 10)
                  Digit.Ten = EMPTY;
                
                if(temp < 100)
                  Digit.Hundred = EMPTY;  
                
                if(temp < 1000)
                  Digit.Thousand = EMPTY;  
            }
        }
  
        digit(znak++);  // Включить первый (младший) разряд индикатора
        
        // Преобразовать значение единиц индикатора в 7-сегментный код и вывести в порт
        display(Digit.One);
        break;
  
      case 1:
        digit(znak++);    // Включить второй разряд индикатора
        
        // Преобразовать значение десятков индикатора в 7-сегментный код и вывести в порт
        display(Digit.Ten);
        
        if((pValue == &Result.TemperatureTC) && (Result.TemperatureTC < 1000))
        {
           PORTB |= (1 << POINT);
        }
        else
        {
           PORTB &= ~(1 << POINT);  
        }
        
        break;
        
      case 2:
        digit(znak++);    // Включить третий разряд индикатора
        
        // Преобразовать значение сотен индикатора в 7-сегментный код и вывести в порт
        display(Digit.Hundred);
        break;        
  
      case 3:
        digit(znak);      // Включить четвертый (старший) разряд индикатора
        
        // Преобразовать значение тысяч индикатора в 7-сегментный код и вывести в порт
        display(Digit.Thousand);        
          
        znak = 0;
        break;
    }
}

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

#define VREF            2500000LL   // VREF = +2.5 V

// 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;

..................