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