/* 
;
Lötstation für Weller LR21

Funktion:
der SIGNAL (TIMER1_OVF_vect) Timerinterrupt (jede Sekunde)
misst die Thermospannung des Kolben über leseAD() und rechnet
diese in °C um.
Die Heizung wir eingeschaltet.
Je nach Regelabweichung wird die Heizung nach einer bestimmten 
Anzahl Nulldurchgänge der Netzspannung wieder ausgeschaltet.
Der Analogkomperator erkennt den Nulldurchgang und löst Interrupt 
(ANA_COMP_vect) aus.
Dort erfolgt auch ein und ausschalten jeweils im Nulldurchgang.
Der Stellwert kann 0 bis 50 Perioden in einer Sekunde betragen.

; Hardware
;              ___________
;       __    /           |      
;+5V O-|__|--|RESET    PC5|--O PWM-AUS - GND
;            |            |      
;         O--|PD0      PC4|--O LED - GND
;            |            |      
;         O--|PD1      PC3|--O Schalter am Ständer - GND
;            |            |     
;     LCD O--|PD2      PC2|--O Taster UP   - GND
;            |            |
;     LCD O--|PD3     ADC1|--O Taster Down - GND
;            |    A T     |
;     LCD O--|PD4     ADC0|--O AD-IN
;            |   mega     |
;     +5V O--|VCC      GND|--O GND
;            |     8      |    
;     GND O--|GND     AREF|--O
;            |            |      
;   XTAL1 O--|XTAL1   AVCC|--O
;            |            |
;   XTAL2 O--|XTAL2 PB5SCK|--O 
;            |            |
;         O--|PD5  PB4MISO|--O 
;            |            |
;         O--|PD6  PB3MOSI|--O LCD 
;            |            |
;         O--|PD7  PB2OC1B|--O LCD
;            |            |
;     LCD O--|PB0  PB1OC1A|--O LCD
;            |____________|
; 
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <stdint.h>
#include <Stdio.h>
#include <avr/eeprom.h>
#include "BinaryNr.h"
#include "lcd.h"


#define F_CPU            1000000    // Interner Takt 1MHz
#define Prescaler 1024;             // Timer 1 Vorteiler
#define startwert 65537-F_CPU/Prescaler; //Zähler Startwert, Überlauf bei 65536

#define u8 unsigned char
#define u16 unsigned int

/* Variablen */
char s[4];                          // Hilfsvariable  
u16 adWert;                         // AD-Wert 
u16 Tist;                           // IstTemperatur 
u16 Tsoll;                          // Solltemperatur 
u16 eeFooWord EEMEM = 280;          // EEprom Speicher

// ##############  A C H T U N G   ######################
// hier an den Temperaturfühler anpassen
// bei Platin- oder PTC-Fühler ausserdem RPTC1 und RPTC2(Brücke) einlöten
//***** edit ***** diese beiden Zeilen für Thermoelementfühler
//float faktor = 0.5889;            // Spannung in Temp. bei Thermoelement
//float n = 20;                     // y = mx + n bei Thermoelement 
//***** edit ***** diese beiden Zeilen für Platin- oder PTC-Fühler
float faktor = 0.73;                // Spannung in Temp. bei PTC
float n = -289;                     // y = mx + n bei PTC

u8 perioden=0;                      // zählt die Anzahl der Perioden (20ms)
u8 stellwert=0;                     // Einschaltdauer von 0 bis 50 (50 Perioden)

/* INIT */
void port_init(void){               // initialize ports 
  DDRC  = B00110000;                // PORTC 4 und 5 als Ausgang
  PORTC = B00001110;                // PullUps für Taster einschalten
}

void ad_init(void){                 // initialize ad-wandler 
  ADMUX = 0x00;                     // Kanal0
  ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung 2,5V nutzen 
  ADCSR=B11000111;                  // enable ADC
}

void ac_init(void){                 // initialize analog-Komparator 
  ACSR=B00001010;                   // enable ADC
}

void timer_init(void){              // timer 1 overflow 
  TCCR1B = B00000101;               // Prescaler auf 1024 stellen
  TIMSK |= (1 << TOIE1);            // Timer 1 Overflow Interrupt enable
  TCNT1  = startwert;               // vorbesetzen (zählt bis FFFF)
}

/* Unterprogramme */

//lies den Temperatur-Startwert aus EEPROM
int Lese_Starttemp(void){
  u16 startTemp;
  startTemp = eeprom_read_word(&eeFooWord); // lese aus EEPROM in startTemp
  if (startTemp==0){
    startTemp=280;
  }   
  return startTemp; 
}

//schreibe den Temperatur-Tsoll ins EEPROM
void Schreibe_Startemp(u16 wert){
   eeprom_write_word(&eeFooWord, wert); // schreibe in EEPROM
}

//lese ad0
int leseAD(void){
  uint16_t wert;                    // Hilfsvariable
  uint8_t  highwert;                // Hilfsvariable
  ADCSR |= (1<<ADSC);               // eine Wandlung starten
  while ( ADCSR & (1<<ADSC) ) {;}   // auf Abschluss der Konvertierung warten
  wert     = ADCL;                  // Low  auslesen  
  highwert = ADCH;                  // High auslesen
  wert = wert + highwert*256;       // 10bit Wert berechnen
  return wert;
}

//Anzeige der Isttemperatur auf LCD
void zeige_Tist(u16 temp){
  itoa(temp,s,10);                  // wert in ACSII
  lcd_gotoxy(0,0);                  // 1. Zeile   
  lcd_puts("aktuell  ");            // Zeichen auf LCD
  lcd_puts(s);                      // Temperatur als ASCII Wert auf LCD
  lcd_puts("\xDF" "C");             // Grad Zeichen                
}

//Anzeige der Solltemperatur auf LCD
void zeige_Tsoll(u16 temp){
  itoa(temp,s,10);                  // wert in ACSII
  lcd_gotoxy(0,1);                  // 2. Zeile   
  lcd_puts("Solltemp.   ");         // Zeichen auf LCD
  lcd_puts(s);                      // Temperatur als ASCII Wert auf LCD
  lcd_puts("\xDF" "C");             // Grad Zeichen                
}


void Pause(void){                   //etwa 0,1s        // nur zu Testzwecken 
  uint8_t i;
  uint8_t j;
  for(i=0;i<6;i++){
    for(j=0;j<250;j++) {}
  }
}

//Analog-Comparator Interrupt Routine je Netzspannungshalbwelle in Nulldurchgang
SIGNAL (ANA_COMP_vect){

  if (perioden==0){                 // Neuer Periodenzyclus hat begonnen
    PORTC |= (1 << 5);              // Heizung einschalten 
    PORTC |= (1 << 4);              // LED einschalten ***test*************
  }
  if (perioden==stellwert){         // Einschaltdauer (Periodenzahl) erreicht
      PORTC &= ~(1 << 5);           // Heizung abschalten
    PORTC &= ~(1 << 4);             // LED abschalten   ****test*********
    }
  perioden++;                       // wieder eine Periode vergangen
}


//Timer Interrupt - kommt genau jede Sekunde
SIGNAL (TIMER1_OVF_vect){           // Timer1 overflow 
  cli();                            // Alle Int. sperren solange in INT-Routine
  TCNT1 = startwert;                // Vorbesetzen (1s)
  perioden=0;                       // neuer Periodenzyclus
  lcd_clrscr();                     // 1.Zeile
  adWert=leseAD();                  // lese Spannungswert 
  Tist = adWert*faktor+n;           // Temperatur berechnen
  zeige_Tist(Tist);                 // anzeigen 
  if(bit_is_clear (PINC,1))         // wenn Taste DOWN gedrückt
  {
    if(Tsoll>10)                    // und min-wert noch nicht erreicht
    {
      Tsoll=Tsoll-10;               // erniedrige Tsoll
    Schreibe_Startemp(Tsoll);       // sichere Tsoll im EEPROM
    }
  }
  if(bit_is_clear (PINC,2))         // wenn Taste UP gedrückt
  {
    if(Tsoll<450)                   // und max-wert noch nicht erreicht  
    {
    Tsoll=Tsoll+10;                 // erhöhe Tsoll
    Schreibe_Startemp(Tsoll);       // sichere Tsoll im EEPROM
    }
  }     
  zeige_Tsoll(Tsoll);               // Solltemp. anzeigen 

// regelung ********************************************
  if (Tsoll<=Tist){                 // zu heiss 
    if (Tist-Tsoll < 10){           // weniger als 10 Grad Abweichung 
     stellwert = 20;                // Heizleistung 40%
    }
  else {                            // Abweichung größer 20 Grad C
      stellwert = 0;                // erst mal gar nicht Heizen
    }
  }
  if (Tsoll>Tist){                  // zu kalt
    if (Tsoll-Tist < 10){           // weniger als 10 Grad Abweichung 
     stellwert = 20;                // Heizleistung 40%
    }
  else {                            // Abweichung größer 20 Grad C
      stellwert = 50;               // 100% Heizleistung
    }
  }

  sei();                            // enable interrupts
}
/*********************/
int main(){
  port_init();                      // Ports initialisieren
  lcd_init(LCD_DISP_ON);            // initialisiere display, cursor off 
  ad_init();                        // AD-Wandler initialisieren
  ac_init();                        // initialisiere analog-Komparator
  timer_init();                     // Timer initialisieren
  Tsoll=Lese_Starttemp();           // Starttemperatur lesen, Vorgabe vom letzten mal 
  Schreibe_Startemp(Tsoll);         // Starttemperatur schreiben    
  lcd_puts("Start... ");            // Startmeldung auf LCD
  sei();                            // enable interrupts  

  for(;;){                          // tue nix Schleife

  }
}