Startversion

// http://www.arduino.cc/playground/Code/FrequencyTimer2
// Tutorial: http://www.hacktronics.com/Tutorials/arduino-1-wire-address-finder.html
// Tutorial: http://www.hacktronics.com/Tutorials/arduino-1-wire-tutorial.html


#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <TimerOne.h>
/////////////////   Aufrufe   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

 LiquidCrystal_I2C lcd(0x27,20,4);  // setzen der LCD Adresse auf0x27, 20 Zeichen und 4 Zeilen

///////////////////   I2C Byte für Abgassensor  /////////////////////////////////////////////////////////////////////////////////////////////

int b1 = 0; // byte 1 I2C Sensor
int b2 = 0; // byte 2 I2C Sensor

///////////////////   Türöffner  /////////////////////////////////////////////////////////////////////////////////////////////

int zeit_x_sekunden = 1;
int Zeit1 = 0;

 
/////////////////   DS18B20
/////////////////   Data wire is plugged into pin D3 on the Arduino

#define ONE_WIRE_BUS 3

/////////////////   Setup a oneWire instance to communicate with any OneWire devices

OneWire oneWire(ONE_WIRE_BUS);

/////////////////   Pass our oneWire reference to Dallas Temperature.

DallasTemperature sensors(&oneWire);



//////////////////////////////////////// Variablen definieren  /////////////////////////////////////////////////////////////////////
/////////////////  für Setup   /////////////////

int ladePumpe = 2;            //Ladepumpe an Pin D2
int abgasTemperatur = 3;      //Temp Sensor Abgas an Pin A3
int klappenStellungsensor = 2; // Klappenstellungs Sensor an PIN A2
int zugLuefter = 10;            // Saugzuglüfter an Pin D10 (PWM fähig)
int tuerKontakt = 9;            // Kontakt der Fülltür an PIN D9
int heizKreispumpe = 8;    // Heizkreispumpe an PIN D8
int freigabeMischer = 6; // Freigabe Mischer an D6
int auf_zu_Mischer = 7; // Mischer Heizkreis auf/zu an D7
int lambdaEingang = 4;  // Lambdasteuerung an PPIN A4

/////////////////  für Loop   /////////////////

int sensorlesen1;            // Stromaufnahme Klappenmotor
int statusKlappe;           // Klappe auf, Klappe zu Variable
int stellungKlappe;          //Stellung der Klappe vom Motorgeber 325=zu; 548=auf
int sicherheitLuefter;    //Variable für Saugzuglüfter wenn über 300°C
int stellungTuer;
int abGasbit;
int speicherVollbit;
int speicherMaxbit;
int kesselMaxbit;
int kesselVollbit;
int anHeizbit;          // 1 = zum Anheizen bereit
int startbit;            // Start Lüfter
int t1;                  // Zähler Anheizen
int heizkreisbit;
int watchDog = 13; //LED blinkt wenn sketch läuft
int startLambda = 4; // Starteingang der Lanbdasteuerung Pin D4 an Pin 6
/////////////////  Global für Setup und Loop   /////////////////

float tempAbgas;
float tempVerbrennung;
float tempKessel;
float tempKesselrueck;
float tempSpeicher_oben;
float tempSpeicher_unten;
float tempReserve;
float tempaussen_Thermometer;
float temphkVorlauf_Thermometer;
float temphkRuecklauf_Thermometer;
float lambdaWert;
float lambdaLesen;

float strom;
int sensorLesen0;
int x;// Zähler für seriell

/////////////////   Klappensteuerung

int klappenSteuerung1 = 11;    // Pin 11 H und Pin 12 L dann Motor zu
int klappenSteuerung2 = 12;    // Pin 11 L und Pin 12 H dann Motor auf
int klappenmotorSensor = 1;    // Motorstrom Pin A1


/////////////////   Tastatur

int eingangTaste = 0;                  //Tasten an Pin A0
int wertTaste;

/////////////////   Sensoren Thimmendorf

DeviceAddress kessel_Thermometer =         { 0x28, 0xFA, 0xC9, 0x96, 0x03, 0x00, 0x00, 0x7E };  //Adressen der Sensoren manuell eingeben
DeviceAddress tempKesselrueck_Thermometer =        { 0x28, 0xC0, 0x97, 0x96, 0x03, 0x00, 0x00, 0x6B };  //Adressen der Sensoren manuell eingeben
DeviceAddress speicher_oben_Thermometer = { 0x28, 0xA6, 0xB7, 0x96, 0x03, 0x00, 0x00, 0xE2 };  //Adressen der Sensoren manuell eingeben
DeviceAddress speicher_unten_Thermometer =  { 0x28, 0x89, 0xA3, 0x96, 0x03, 0x00, 0x00, 0x13 };  //Adressen der Sensoren manuell eingeben
DeviceAddress reserve_Thermometer =        { 0x28, 0xDC, 0xC0, 0x96, 0x03, 0x00, 0x00, 0x89 };  //Adressen der Sensoren manuell eingeben
DeviceAddress aussen_Thermometer =         { 0x28, 0xA5, 0x9E, 0x96, 0x03, 0x00, 0x00, 0xB0 };  // Außentemperatur
DeviceAddress hkVorlauf_Thermometer =        { 0x28, 0x18, 0xAC, 0x96, 0x03, 0x00, 0x00, 0xFA }; // Heizkreis Vorlauf
DeviceAddress hkRuecklauf_Thermometer =        { 0x28, 0x26, 0xC7, 0x96, 0x03, 0x00, 0x00, 0x65 }; //Heizkreis Ruecklauf

/*Sensoren Reserve
DeviceAddress speicher_oben_Thermometer =  { 0x28, 0x69, 0xC2, 0x96, 0x03, 0x00, 0x00, 0xE6 };
DeviceAddress speicher_unten_Thermometer = { 0x28, 0x7F, 0xAE, 0x96, 0x03, 0x00, 0x00, 0x3F };
*/

void setup ()
{

/////////////////   initialisieren serielle Schnittstelle auf 9600 Baud    /////////////////

Serial.begin(9600);
Serial.println("Start");

/////////////////   initialisiere lcd    /////////////////


lcd.init();                     
lcd.backlight();
lcd.clear();
lcd.print("Start");


pinMode(ladePumpe, OUTPUT);
pinMode(klappenSteuerung1, OUTPUT);
pinMode(klappenSteuerung2, OUTPUT);
pinMode(zugLuefter, OUTPUT);
pinMode(tuerKontakt, INPUT);
pinMode (heizKreispumpe, OUTPUT);
pinMode (freigabeMischer,OUTPUT);
pinMode (auf_zu_Mischer,OUTPUT);
pinMode (watchDog,OUTPUT);
pinMode (startLambda, OUTPUT);






/////////////////  Anheizklappe definiert   /////////////////

digitalWrite (klappenSteuerung1, LOW);                                    // beide je L Motor steht
digitalWrite (klappenSteuerung2, LOW);                                   // beide je L Motor steht

/////////////////  Sensore Kessel   /////////////////

//////////////// lesen den Sensorwert I2C ein 
///////////////// Umrechnung in Grad Celsius bei Betriebsspannung von 5 Volt///////
//  Mit folgender Formel:
//  b1 << 8 , das entspricht der Multiplikation mit 256, also 14*256
//  das ganze plus b2, also + 46
//  Dann die Formel aus dem Datenblatt für den Sensor R3 (ist geraten, denn hier passt der Wert zum gemessenen Wert)
//  V/64 - 32
//  das entspricht dann:
//  (14*256+46)/64-32 = 24,71875 ~ 24,72°C               
   Wire.begin();     // I2C Bus starten
   Wire.requestFrom(0x78,2); // lese von adress 0x78 2 bytes aus
   b1 = Wire.read(); // lese 1. byte
   b2 = Wire.read(); // lese 2. byte
   tempVerbrennung = (b1 << 8 | b2)/64-32; // Brennraumtemperatur
///////////I2C Ende

sensorLesen0 = analogRead(abgasTemperatur); //lesen den Sensorwert aus Pin A3 ein
tempAbgas = (5.0 * sensorLesen0 * 100 / 1024-35); //Umrechnung in Grad Celsius bei Betriebsspannung von 5 Volt, -35 Korrektur des Meßwertes

/////////////////////////Lambda Wert einlesen

lambdaLesen = analogRead (lambdaEingang); // lesen den Lambdawert aus Pin A4 ein
lambdaWert = (lambdaLesen / 204.8*4.2);// 1024 Digit/ 204,8=5V  5V*4,4=21%



/////////////////  Türkontakt Timer   /////////////////

    Timer1.initialize(zeit_x_sekunden*1000000);
    Timer1.attachInterrupt(TuerOeffner_function);


///////////////// DS18B20Anfang
///////////////// Start der library DS18B20

  sensors.begin();   
 
///////////////// Auflösung des Sensors auf 9 bit 

  sensors.setResolution(kessel_Thermometer, 9);
  sensors.setResolution(tempKesselrueck_Thermometer, 9);
  sensors.setResolution(speicher_oben_Thermometer, 9);
  sensors.setResolution(speicher_unten_Thermometer, 9);
  sensors.setResolution(reserve_Thermometer, 9);
  sensors.setResolution(aussen_Thermometer, 9);
  sensors.setResolution(hkVorlauf_Thermometer, 9);
  sensors.setResolution(hkRuecklauf_Thermometer, 9);
 
/////////////////  Start abfrage DS18B20

  sensors.requestTemperatures();     

/////////////////  Temperatur DS18b20 in Varable ablegen

  tempKessel = sensors.getTempC(kessel_Thermometer);                    
  tempKesselrueck = sensors.getTempC(tempKesselrueck_Thermometer);
  tempSpeicher_oben = sensors.getTempC(speicher_oben_Thermometer);
  tempSpeicher_unten = sensors.getTempC(speicher_unten_Thermometer);
  tempReserve = sensors.getTempC(reserve_Thermometer);
  tempaussen_Thermometer = sensors.getTempC(aussen_Thermometer);
  temphkVorlauf_Thermometer = sensors.getTempC(hkVorlauf_Thermometer);
  temphkRuecklauf_Thermometer = sensors.getTempC(hkRuecklauf_Thermometer);
 
//////////////// Einlesen Stellung Klappe 

  stellungKlappe = analogRead(klappenStellungsensor);
  //alt if ((stellungKlappe <= 380) && (stellungKlappe >= 320)) statusKlappe = 0; // Klappe zu wenn Drehgeber bei ca. 335
  //alt if ((stellungKlappe <= 555) && (stellungKlappe >= 545)) statusKlappe = 1; // Klappe auf wenn Drehgeber bei ca. 550
  if ((stellungKlappe <= 535) && (stellungKlappe >= 530)) statusKlappe = 0; // Klappe zu wenn Drehgeber bei ca. 531
  if ((stellungKlappe <= 675) && (stellungKlappe >= 670)) statusKlappe = 1; // Klappe auf wenn Drehgeber bei ca. 674
 
 
 
 
 
 
/////////////////////////////Ende Setup 
 
}

void TuerOeffner_function(){

    Zeit1 = Zeit1++;

}


void loop()
{
//////////////////  WatchDog   ////////////////////////

if ((x >= 0)&& (x <=4)) digitalWrite (watchDog, HIGH);
if ((x >= 5) && ( x <= 10)) digitalWrite (watchDog, LOW);

/////////////////////////Lambda Wert einlesen

lambdaLesen = analogRead (lambdaEingang); // lesen den Lambdawert aus Pin A4 ein
lambdaWert = (lambdaLesen / 204.8*4.2);// siehe Setup

 
 
/////////////////   Stromaufnahme Klappenmotor einlesen    /////////////////

    sensorlesen1 = analogRead(klappenmotorSensor); //lesen den Sensorwert in Pin A1 ein
    strom =(sensorlesen1 / 100);

/////////////////   Abschaltung Klappenmotor bei Überlast    /////////////////
   
        if (strom >= 3.0)                                              //Strom größer 3A
            {
            digitalWrite (klappenSteuerung2, LOW); // Motor stopp
            digitalWrite (klappenSteuerung1, LOW);// Motor stopp
            }

/////////////////   Tasten einlesen    /////////////////
   
    wertTaste = analogRead(eingangTaste); // lesen Wert für Taste

/////////////////   Stellung Klappe Abfragen    /////////////////
   
    stellungKlappe = analogRead(klappenStellungsensor);
        if ((stellungKlappe <= 535) && (stellungKlappe >= 530)) statusKlappe = 0; // Klappe zu wenn Drehgeber bei ca. 531
        if ((stellungKlappe <= 675) && (stellungKlappe >= 670)) statusKlappe = 1; // Klappe auf wenn Drehgeber bei ca. 674
        //if ((stellungKlappe < 380) || (stellungKlappe > 556)) statusKlappe = 3;   // Klappe Fehler
        if ((stellungKlappe > 535) && ( stellungKlappe < 670)) statusKlappe = 2;    // Klappe läuft

/////////////////   Temperaturen abfragen    /////////////////

        //I2C
        Wire.requestFrom(0x78,2); // lese von adress 0x78 2 bytes aus
        b1 = Wire.read(); // lese 1. byte
        b2 = Wire.read(); // lese 2. byte
        tempVerbrennung = (b1 << 8 | b2)/64-32; // Brennraumtemperatur
       
       
        sensorLesen0 = analogRead(abgasTemperatur); //lesen den Sensorwert in Pin A3 ein
        tempAbgas = (5.0 * sensorLesen0 * 100 / 1024-35); //Umrechnung in Grad Celsius bei Betriebsspannung von 5 Volt, -35 Korrektur des Meßwertes

        //DS18B20
        sensors.requestTemperatures();//DS18B20
        tempKessel = sensors.getTempC(kessel_Thermometer);
        tempKesselrueck = sensors.getTempC(tempKesselrueck_Thermometer);
        tempSpeicher_oben = sensors.getTempC(speicher_oben_Thermometer);
        tempSpeicher_unten = sensors.getTempC(speicher_unten_Thermometer);
        tempReserve = sensors.getTempC(reserve_Thermometer);
        tempaussen_Thermometer = sensors.getTempC(aussen_Thermometer);
        temphkVorlauf_Thermometer = sensors.getTempC(hkVorlauf_Thermometer);
        temphkRuecklauf_Thermometer = sensors.getTempC(hkRuecklauf_Thermometer);
///////////////////////Start Messung Lambda///////////////////////////////////////////////////////////////////////////////////////////////////////////////

        if (tempAbgas >= 40) digitalWrite (startLambda, LOW); //Lambdasonde wird geheizt und die Messung beginnt
        else digitalWrite (startLambda, HIGH);

       
//////////////////   Lüftersteuerung   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       
        if (tempAbgas >= 300) abGasbit = 0;
        else abGasbit = 1;
       
        if (tempSpeicher_oben > 95) speicherMaxbit = 0;
        else speicherMaxbit = 1;
       
        if ((tempSpeicher_oben == tempSpeicher_unten) && (tempSpeicher_oben > 90)) speicherVollbit = 0;
        else speicherVollbit = 1;
       
        if (tempKessel > 95) kesselMaxbit = 0;
        else kesselMaxbit = 1;
       
        if ((tempKesselrueck == tempKessel) && (tempKessel > 90)) kesselVollbit = 0;
        else kesselVollbit = 1;
       
        if ((abGasbit == 1) && (speicherMaxbit == 1) && (speicherVollbit == 1) && (kesselMaxbit == 1) && (kesselVollbit == 1) && (anHeizbit == 1)) digitalWrite (zugLuefter, HIGH);
        else digitalWrite (zugLuefter, LOW);
       
///////////////////// Tür auf Lüfter für 30 min an, dann aus es sei denn die Temperatur Abgas ist über 50°

        if ((digitalRead (tuerKontakt)) == HIGH) stellungTuer = 1;    //Tür auf
        if ((digitalRead (tuerKontakt)) == LOW) stellungTuer = 0;    // Tür zu
       
        if ((tempAbgas < 50) && (startbit == 0)) anHeizbit = 0;
        else anHeizbit = 1;
       
        if (stellungTuer == 1) anHeizbit = 1;         
        if (stellungTuer ==1) startbit = 1;
         
        if (startbit == 1) t1++;
        if (t1 == 3000)
           {
             startbit = 0;
             t1 = 0;
           }

        /////////////     Lüfter manuell aus so lange Taste gehalten

        if (( wertTaste >= 510) && (wertTaste <= 520))     // auf Wert 512
            {
            startbit = 0;                                // Lüfter aus
            }        

          
        //if (tempAbgas > 50)
        //  {
        //    Zeit1 = 0;          //Zeit1 rücksetzen wenn Abgas über 50°, weil Kessel läuft
        //    digitalWrite (zugLuefter, HIGH);
        //  } 
        // mann sollte hier parameter setzen da bei einer Temperatur von 51 °C, er wieder 30 min wartet       
       
       
/////////////////   Steuerung Ladepumpe nach Kesseltemperatur   /////////////////

        if(tempKessel > 50)
            {
            digitalWrite (ladePumpe, HIGH);
            } 
            else
            {
            digitalWrite(ladePumpe, LOW);
            }
       
/////////////////   Steuerung Klappenmotor nach Abgastemperatur    /////////////////

        if ((tempAbgas >= 190) && (statusKlappe == 1))
            {
            digitalWrite (klappenSteuerung1, HIGH); // Temperatur >250 Motor läuft zu        
            }

        if ((tempAbgas <= 50) && (statusKlappe == 0))
            {
            digitalWrite (klappenSteuerung2, HIGH);// Temperatur >250 Motor läuft auf
            }


        /////////   Klappensteuerung manuell    /////////////////

        if (( wertTaste >= 30) && (wertTaste <= 40))      // Motor manuell (auf Wert 35)
            {
            digitalWrite (klappenSteuerung1, HIGH);  // Motor läuft
            digitalWrite (klappenSteuerung2, LOW);   // Motor läuft   
            }

        if (( wertTaste >= 60) && (wertTaste <= 70))     // Motor manuell zu (auf Wert 64)
            {
            digitalWrite (klappenSteuerung1, LOW);   // Motor läuft
            digitalWrite (klappenSteuerung2, HIGH);  // Motor läuft
            }

           
//////////////       Heizkreisteuerung     ///////////////////////
       
        if (tempSpeicher_oben >= 45)
                    {
                    digitalWrite (heizKreispumpe, HIGH); 
                    heizkreisbit = 1;
                    }
        else
                    {
                    digitalWrite(heizKreispumpe, LOW); 
            heizkreisbit = 0;
                    }
/////////////         Mischersteuerung     
       
                if (temphkVorlauf_Thermometer > 50) digitalWrite (auf_zu_Mischer, HIGH);
        if (temphkVorlauf_Thermometer < 50)digitalWrite (auf_zu_Mischer, LOW);
         
                if ((temphkVorlauf_Thermometer >= 48 ) && (temphkVorlauf_Thermometer <= 52 ) && (heizkreisbit == 1)) digitalWrite (freigabeMischer, LOW); // RelaisSteuerung negiert
                else digitalWrite (freigabeMischer, HIGH);  // RelaisSteuerung negiert
               
               
/////////////////   Ausgabe Display    /////////////////
//if ((x > 0) && (x < 10))
//{
    lcd.setCursor(0, 0);
    lcd.print("Abgas");
    lcd.setCursor(6, 0);
    lcd.print(tempAbgas,1);
    lcd.setCursor(0, 1);
    lcd.print("Kess");
    lcd.setCursor(5, 1);
    lcd.print(tempKessel,1);
    lcd.setCursor(0, 2);
    lcd.print("Sp_ob");
    lcd.setCursor(7, 2);
    lcd.print(tempSpeicher_oben,1);
    lcd.setCursor(0, 3);
    lcd.print("Sp_un");
    lcd.setCursor(7, 3);
    lcd.print(tempSpeicher_unten,1);
    lcd.setCursor(12, 0);
    lcd.print("O2");
    lcd.setCursor(16, 0);
       
        /*
    switch (statusKlappe)
    {

        case 0 : lcd.print("zu ");
            break;
          case 1 : lcd.print("auf");
            break;
                case 2 : lcd.print("lau");
            break;
        default : lcd.print("err");
            break;
    }
        */
    lcd.print (lambdaWert,2);
       
    lcd.setCursor(10, 1);    
    lcd.print("Auss");
    lcd.setCursor(15, 1);
    lcd.print(tempaussen_Thermometer,1);
    lcd.setCursor(12, 3);
    lcd.print("HVL");
    lcd.setCursor(16, 3);
    lcd.print(temphkVorlauf_Thermometer,1);
    lcd.setCursor(12, 2);
    lcd.print("HRL");
    lcd.setCursor(16, 2);
    lcd.print(temphkRuecklauf_Thermometer,1);
//}  

/*if ((x > 10) && (x < 20))
{
    lcd.setCursor(0, 0);
    lcd.print("tuer");
    lcd.setCursor(6, 0);
    lcd.print(stellungTuer);
    lcd.setCursor(0, 1);
    lcd.print("smax");
    lcd.setCursor(7, 1);
    lcd.print(speicherMaxbit);
    lcd.setCursor(0, 2);
    lcd.print("svol");
    lcd.setCursor(7, 2);
    lcd.print(speicherVollbit);
    lcd.setCursor(0, 3);
    lcd.print("kmax");
    lcd.setCursor(7, 3);
    lcd.print(kesselMaxbit);
    lcd.setCursor(12, 0);
    lcd.print("Klap");
    lcd.setCursor(17, 0);
    lcd.print ( stellungKlappe);
    lcd.setCursor(12, 1);    
    lcd.print("kvol");
    lcd.setCursor(17, 1);
    lcd.print(kesselVollbit);
    lcd.setCursor(12, 3);
    lcd.print("anh");
    lcd.setCursor(16, 3);
    lcd.print(anHeizbit);
    lcd.setCursor(12, 2);
    lcd.print("sta");
    lcd.setCursor(16, 2);
    lcd.print(startbit);
}
if (x == 10) lcd.clear();
if (x == 20) x = 1;
*/
   
/////////////////   Ende    /////////////////
/////////////////   Ausgabe Seriell    /////////////////
if (x == 10)
{
    Serial.print("Abgastemperatur ist: ");
    Serial.println(tempAbgas);
    Serial.print("Sauerstoff ist: ");
    Serial.println(lambdaWert);   
    Serial.print("Verbrennung ist: ");
    Serial.println(tempVerbrennung);   
    Serial.print("Strom ist: ");
    Serial.println(strom);
    Serial.print("Status Klappe= ");
    Serial.println(statusKlappe);
    Serial.print("Taste ");
    Serial.println(wertTaste);
    Serial.print("Kessel Temperatur ist: ");
    Serial.println(tempKessel);
    Serial.print("Ruecklauf Kessel Temperatur ist: ");
    Serial.println(tempKesselrueck);
    Serial.print("Speicher oben Temperatur ist: ");
    Serial.println(tempSpeicher_oben);
    Serial.print("Speicher unten Temperatur ist: ");
    Serial.println(tempSpeicher_unten);
    Serial.print("Reserve Temperatur ist: ");
    Serial.println(tempReserve); 
    Serial.print("Position Motor ");
    Serial.println(stellungKlappe);
    Serial.print("Stellung Tuer ");
    Serial.print(stellungTuer);
    Serial.print(" ");
    Serial.println(tuerKontakt);
    Serial.print("Zeit1 ");
    Serial.println(Zeit1);
    Serial.println("Luefterbits, Abgas, Speichermax, Speichervoll, Kesselmax, Kesselvoll ");
    Serial.print(abGasbit);
    Serial.print(" ");
    Serial.print(speicherVollbit);
    Serial.print(" ");
    Serial.print(speicherMaxbit);
    Serial.print(" ");
    Serial.print(kesselMaxbit);
    Serial.print(" ");
    Serial.print(kesselVollbit);
    Serial.print(" ");
   
    Serial.println();
   
   
    x = 0;
}
x ++;

/////////////////////Programm Ende///////////////////////
}