/*******************************************************
Projekt:        Aetzwanne

Version :        ATTiny25 - 1
Erstellt:        20.09.2016
Letze Aenderung: 25.09.2016

Chip: Attiny25 mit internen 8.0 MHz
*******************************************************/

/// Header-Dateien///
#include <io.h>
#include <delay.h>

/// Definierungen ///
#define Lastwiderstaende    PORTB.0
#define DataOut             PORTB.1
#define InterruptOut        PORTB.2   
#define Target_low          40          //Minimale Temperatur
#define Target_high         45          //Maximale Temperatur

// Bandgap Voltage Reference: Off
#define ADC_VREF_TYPE ((0<<REFS0) | (0<<ADLAR))

//// Prototypen ////
int read_adc ();

/// Globale Variablen ///
char temp = 0;
char temp_part = 0;

char temp_einer_bit0 = 1;
char temp_einer_bit1 = 0;
char temp_einer_bit2 = 0;
char temp_einer_bit3 = 0;

char temp_zehner_bit0 = 0;
char temp_zehner_bit1 = 1;
char temp_zehner_bit2 = 0;
char temp_zehner_bit3 = 0;

void main(void)
{
    // Crystal Oscillator division factor: 1
    #pragma optsize-
    CLKPR=(1<<CLKPCE);
    CLKPR=(0<<CLKPCE) | (0<<CLKPS3) | (0<<CLKPS2) | (0<<CLKPS1) | (0<<CLKPS0);
    #ifdef _OPTIMIZE_SIZE_
    #pragma optsize+
    #endif

    // Port Initialisierung
    // Port B -  Bit5 = Out, Bit4 = Out, Bit3 = Out, Bit2 = Out, Bit1 = Out, Bit0 = In   
    DDRB=(1<<DDB5) | (1<<DDB4) | (1<<DDB3) | (1<<DDB2) | (1<<DDB1) | (0<<DDB0);
    PORTB=(0<<PORTB5) | (0<<PORTB4) | (0<<PORTB3) | (0<<PORTB2) | (0<<PORTB1) | (0<<PORTB0); 
    
    //ADC Initialisierung
    ADMUX |= (1 << MUX0);  //ADC3 (PB3), Output vom LM335
    ADMUX |= (1 << MUX1); 
    ADCSRA |= (1 << ADPS1) | (1 << ADPS0) | (1 << ADEN);    //Frequenz: 62.5 kHz  
                   
    delay_ms(100);   //Sicherstellen, dass Attiny2313 empfangsbereit ist
    
    while (1)
    {      
        /// Temperatur einlesen ///
	//Temperatur in Celsius errechnen (10mV/K)
        temp = read_adc() * 0.00488759 * 100 - 273.15; 
        
        /// Temperatur auswerten ///
	//Temperatur zu niedrig? Lastwiderstaende ein
        if (temp < Target_low)                             
            Lastwiderstaende = 1;
                              
	//Temperatur zu hoch? Lastwiderstaende aus
        else if (temp > Target_high)                    
            Lastwiderstaende = 0; 
                         
        /// Temperatur zerlegen ///
        //Einerstelle in BCD zerlegen 
        temp_part = temp % 10;                        
        
        switch (temp_part)
        {     
            case 0:
                temp_einer_bit0 = 0;
                temp_einer_bit1 = 0;
                temp_einer_bit2 = 0;
                temp_einer_bit3 = 0;
                break; 
                    
            case 1:
                temp_einer_bit0 = 1;
                temp_einer_bit1 = 0;
                temp_einer_bit2 = 0;
                temp_einer_bit3 = 0;
                break;
                    
            case 2:
                temp_einer_bit0 = 0;
                temp_einer_bit1 = 1;
                temp_einer_bit2 = 0;
                temp_einer_bit3 = 0;
                break;   
                    
            case 3:
                temp_einer_bit0 = 1;
                temp_einer_bit1 = 1;
                temp_einer_bit2 = 0;
                temp_einer_bit3 = 0;
                break;
                    
            case 4:
                temp_einer_bit0 = 0;
                temp_einer_bit1 = 0;
                temp_einer_bit2 = 1;
                temp_einer_bit3 = 0;
                break;
                    
            case 5:
                temp_einer_bit0 = 1;
                temp_einer_bit1 = 0;
                temp_einer_bit2 = 1;
                temp_einer_bit3 = 0;
                break;
                    
            case 6:
                temp_einer_bit0 = 0;
                temp_einer_bit1 = 1;
                temp_einer_bit2 = 1;
                temp_einer_bit3 = 0;
                break;
                    
            case 7:
                temp_einer_bit0 = 1;
                temp_einer_bit1 = 1;
                temp_einer_bit2 = 1;
                temp_einer_bit3 = 0;
                break;
                    
            case 8:
                temp_einer_bit0 = 0;
                temp_einer_bit1 = 0;
                temp_einer_bit2 = 0;
                temp_einer_bit3 = 1;
                break;
                    
            case 9:
                temp_einer_bit0 = 1;
                temp_einer_bit1 = 0;
                temp_einer_bit2 = 0;
                temp_einer_bit3 = 1;
                break;
        }         
        
        //Zehnerstelle in BCD zerlegen 
        temp_part = (temp - temp_part) / 10;
        
        switch (temp_part)
        {     
            case 0:
                temp_zehner_bit0 = 0;
                temp_zehner_bit1 = 0;
                temp_zehner_bit2 = 0;
                temp_zehner_bit3 = 0;
                break; 
                    
            case 1:
                temp_zehner_bit0 = 1;
                temp_zehner_bit1 = 0;
                temp_zehner_bit2 = 0;
                temp_zehner_bit3 = 0;
                break;
                    
            case 2:
                temp_zehner_bit0 = 0;
                temp_zehner_bit1 = 1;
                temp_zehner_bit2 = 0;
                temp_zehner_bit3 = 0;
                break;   
                    
            case 3:
                temp_zehner_bit0 = 1;
                temp_zehner_bit1 = 1;
                temp_zehner_bit2 = 0;
                temp_zehner_bit3 = 0;
                break;
                    
            case 4:
                temp_zehner_bit0 = 0;
                temp_zehner_bit1 = 0;
                temp_zehner_bit2 = 1;
                temp_zehner_bit3 = 0;
                break;
                    
            case 5:
                temp_zehner_bit0 = 1;
                temp_zehner_bit1 = 0;
                temp_zehner_bit2 = 1;
                temp_zehner_bit3 = 0;
                break;
                    
            case 6:
                temp_zehner_bit0 = 0;
                temp_zehner_bit1 = 1;
                temp_zehner_bit2 = 1;
                temp_zehner_bit3 = 0;
                break;
                    
            case 7:
                temp_zehner_bit0 = 1;
                temp_zehner_bit1 = 1;
                temp_zehner_bit2 = 1;
                temp_zehner_bit3 = 0;
                break;
                    
            case 8:
                temp_zehner_bit0 = 0;
                temp_zehner_bit1 = 0;
                temp_zehner_bit2 = 0;
                temp_zehner_bit3 = 1;
                break;
                    
            case 9:
                temp_zehner_bit0 = 1;
                temp_zehner_bit1 = 0;
                temp_zehner_bit2 = 0;
                temp_zehner_bit3 = 1;
                break;
        }   
        
        /// Temperaturwert uebertragen ///
        //Einerstelle uebertragen
        DataOut = temp_einer_bit0;   //Zu uebertragendes Bit anlegen
        InterruptOut = 1;            //Signalisieren, dass Bit angelegt ist
        delay_ms(1);                 //Warten, bis Bit uebernommen ist
        InterruptOut = 0;
        delay_ms(1);       
        
        DataOut = temp_einer_bit1;  
        InterruptOut = 1;            
        delay_ms(1);                 
        InterruptOut = 0;
        delay_ms(1);
        
        DataOut = temp_einer_bit2;   
        InterruptOut = 1;            
        delay_ms(1);                
        InterruptOut = 0;
        delay_ms(1);
        
        DataOut = temp_einer_bit3;   
        InterruptOut = 1;            
        delay_ms(1);                 
        InterruptOut = 0;
        delay_ms(1);
                
        //Zehnerstelle
        DataOut = temp_zehner_bit0;   
        InterruptOut = 1;            
        delay_ms(1);                 
        InterruptOut = 0;
        delay_ms(1);
        
        DataOut = temp_zehner_bit1;   
        InterruptOut = 1;            
        delay_ms(1);                 
        InterruptOut = 0;
        delay_ms(1);
        
        DataOut = temp_zehner_bit2;   
        InterruptOut = 1;            
        delay_ms(1);                 
        InterruptOut = 0;
        delay_ms(1);
        
        DataOut = temp_zehner_bit3;   
        InterruptOut = 1;           
        delay_ms(1);                 
        InterruptOut = 0;
        delay_ms(1);    
        
        //Warten bis zur naechten Messung
        delay_ms(1000);     
     }  
}

/// Funktionen ///
int read_adc ()
{    
    // ADC starten
    ADCSRA |= (1 << ADSC);

    // Auf Ende des Messvorgangs warten
    while (ADCSRA & (1 << ADSC));
          
    // 10-Bit-Ergebnis zurueckgeben
    return (ADCH<<8 | ADCL);
}