sauber.ino

/*

Programmname          : Arduino Uno-Shild-Lüftersteuerung                                          

Author                : Michael.V                                                     

Erstelldatum          : 17.01.2018                                                    

Funktionsbeschreibung : - Zwei Temperatur Sensoren 

                        - Zwei PWM-Ausgänge für Ventilatoren

                        - Remote Control ( Anzeige ändern, Auto/manuel umschalten)

                        - Lüfter PWM geteuert .. Manuel/Automatisch(PID-Regler)

                        - I²C - Bus Schnittstelle für Luftfeuchtigkeitssensor oder ähnliches

*/

/* 

        Anzeige

- Temperatur 1

- Temperatur 2

- Stellgröße aus PID regler (Wenn man_auto= 1 wird PID-Wert auf Stellwert 1&2 geschrieben)

- Manuelle Stellgröße 1

- Manuelle Stellgröße 2

- Sollwert (Temperatur bei Temperaturmessstation 2)

*/

// Verwendete Bibliotheken

#include <Arduino.h>

#include <math.h>         // Für Temp u PID Berechnung

#include <TimerOne.h>     // Für Interrupt Timer^1

#include "SevSeg.h"       // Für 7-Seg_Anzeige

#include <IRremote.h>     // Für Fernbedienung

#include <Wire.h>         // Für PWM comunikation

// Register Adresse Lüfter

#define Luefter1 0x04

#define Luefter2 0x02

// I²C Adresse PWM_IC

#define pwm_ic 0x62

// Channel für Temperatur

#define T1 A0

#define T2 A1

// Objekte

IRrecv irrecv(A2);        // inizialisiert Empfänger an Pin A2

decode_results results;   // decodiert empfangendes in results

SevSeg sevseg;            // 7-Seg-Objekt um Funktionen zu nutzen

// Variable für Timer

unsigned long timer  = millis();         

unsigned long timer2 = millis();  

// Variable für Manuel/Automatisch

int man_auto;

// Verhindert dauerhaftes Aufrufen

int counter;

// Variablen für Temperatur

float temp_1;

float temp_2;

// Buffer für Temperatur Berechnung

float temp1[10];

float temp2[10];          

// Variablen für Lüfter

float man_stell_1 =0.00;         // Manuele_1 Stellgröße_1

float man_stell_2 =0.00;         // Manuele_2 Stellgröße_2     

float auto_stell  =0.00;         // Stellgröße aus PID-Regler

float Sollwert    =22.0;         // Merkt sich Sollwert

// Werte vom letzten durchlauf

byte stell_manuel_1_alt=0;         // Speichert stell_manuel_1_alt für vergleich

byte stell_manuel_2_alt=0;         // Speichert stell_manuel_1_alt für vergleich

byte stell_auto_alt    =0;         // Speichert stell_auto_alt für vergleich

// Stellgrößen Lüfter

byte stell_manuel_1=0;               // Für Stellgröße 1

byte stell_manuel_2=0;               // Für Stellgröße 2

byte stell_auto    =0;               // Für Auto_stellgröße

// Standby

int standbye=0;

  // Für 7-Seg Anzeige

byte numDigits = 4;

byte digitPins[] = {8, 11, 12, 7};               // 7 Seg Anzeige Ziffer   

byte segmentPins[] = {9, 13, 5, 3, 2, 10, 6, 4}; // 7 Seg segment a,b,c,d,e,f,g,punkt

bool resistorsOnSegments = false; 

byte hardwareConfig = COMMON_CATHODE; 

bool updateWithDelays = false; 

bool leadingZeros = false; 

// Auswahl display

int auswahl=0;

//Für PID Regler

// Diese Werte müssen gespeichert werden

static float En=0.0,en1=0.0,en2=0.0;

static float Yn=0.0,yn1=0.0;

float delta_y;

// variable mindest stellgroße

int untere_schwelle = 40;

// mindest Temperatur Ofen

int min_temp_ofen = 30;

//////////////////////////////////////////////// Config //////////////////////////////////////////////////////

void setup() {

  // join i2c bus 

  Wire.begin(); 

  // aktiviert Serialle-Verbindung für debugg

  Serial.begin(57600);

  // inizialisiert Eingänge/Ausgänge

  ini_io();

  // inizialisiert 7 Segmnt Anzeige

  ini_sev_seg();   

  // aktiviert Fernbedienung

  irrecv.enableIRIn(); 

  // Interrut Timer setzen refresh Display

  Timer1.initialize(3000);                    // Timer 0.3 Sec

  Timer1.attachInterrupt(Refresh);           // Interrupt Rountine

  // inizialisiert PWM-IC-config

  ini_pca9533();

  // Grundeinstellung

  PWMaus();

}

////////////////////////////////////////////////// LOOP ////////////////////////////////////////////////////

void loop() {

  IR_auswerten();

  // Refresh Werte ~ alle 0.1 sec für Stellgröße Fernbedienung

  if (millis() - timer >= 100) {

    timer += 100;

    auswahl_fuer_display();

  }   

  // Refresh Werte ~ alle 0.5 sec für Temperatur

  if (millis() - timer2 >= 500){

    timer2 += 500;  

    update_temperatur();

    luefterstellen();

  }

}

////////////////////////////////////////////////// Funktionen //////////////////////////////////////////////

void update_temperatur(){

  // 10 Temperatur Messungen T1  

  for(int i=0 ; i<10 ; i++){

    temp1[i]=Temperatur(T1);

  }

  // aufaddieren T1 Werte

  for (int j=0 ; j<10 ; j++){

    temp_1+=temp1[j];

  }

  // 10 Temperatur Messungen T2

  for(int k=0 ; k<10 ; k++){

    temp2[k]=Temperatur(T2);

  }

  // aufaddieren T2 Werte

  for (int l=0 ; l<10 ; l++){

    temp_2+=temp2[l];

  }

  // Mittelwertberechnung

  temp_1/=10;

  temp_2/=10;

  // PID Werte werden berechnet wenn Temperatur Wert 1 > Sollwert Istwert

  // Wenn Ofen <30°C ist muss kein PID Wert berechnet werden  

  if ((int)temp_1 > min_temp_ofen){

    if (man_auto == 1) auto_stell=PIDRegler(Sollwert,temp_2);

  }

  if (auswahl == 0 ) sevseg.setNumber(temp_1, 2);    // Übergibt Temperatur 1 an 7-Seg-Anzeige

  if (auswahl == 1 ) sevseg.setNumber(temp_2, 2);    // Übergibt Temperatur 2 an 7-Seg-Anzeige

}

// Funktion für Temperaturauswertung

float Temperatur(char Sensor){

    int B = 4275;                                    // Werte aus Datenblatt für genaue Berechnung          

    int R0 = 100000;                                 // Werte aus Datenblatt für genaue Berechnung

    int a = analogRead(Sensor);                      // Ließt Wert vom Analogen-Eingang

    float R = 1023.0/a-1.0;                          // Werte aus Datenblatt für genaue Berechnung 

    R = R0*R;   

    float temp = 1.0/(log(R/R0)/B+1/298.15)-273.15;  //Werte aus Datenblatt für genaue Berechnung 

    return temp;                                     // Gibt Temperatur zurück und springt ins Hautprogramm zurück         

}

// wird alle 0.3 Sekunden Aufgerufen um Zahlen zu updaten

void Refresh(){

  if (auswahl==5){

    digitalWrite( 8 ,HIGH);                         // Schaltet Ziffer 1 aus 

    digitalWrite(11 ,HIGH);                         // Schaltet Ziffer 2 aus

    digitalWrite(12 ,HIGH);                         // Schalter Ziffer 3 aus

    digitalWrite( 7 ,HIGH);                         // Schaltet Ziffer 4 aus

  }

  if (auswahl!=5) sevseg.refreshDisplay();          // bewirkt das Zahlen angezigt werden-- nur bei auswahl != 5 

} 

float PIDRegler(float T1,float T2){

  // Empfindlichkeit des PID-Reglers

float Tn = 1.0;

float Tv = 1.0;

float Kp = 1.0;

  // Variablen für P,I,D

float P,I,D;

  // Zeitkostante 

float delta_t=0.5;

En = T1 - T2;       // T1 = Temperatur_1 = Sollwert hier 

                    // T2 = Temperatur_2 = Istwert

                    // En = Regelabweichung

// Berechnugn P I D

P = En - en1;

D = (delta_t / Tn) * En;

I = Tv * (En - 2 * en1 + en2);

// Berechnung neuer Stellgröße

delta_y = Kp * ( P + D + I);

Yn = yn1 + delta_y;

// Speichert alte Werte

en2 = en1;

en1 = En;

yn1 = Yn;

// Begrenzt Yn auf 100

if (Yn > 100.0) Yn=99.99;

if (Yn <   0.0) Yn=  0.0;

// Gibt Stellgröße zurück und springt ins Hautprogramm zurück

return Yn;  

}

void resetPID(void){

  en2=0;

  en1=0;

  yn1=0;

  En=0;

  Yn=0;

  delta_y=0; 

}

void PWMaus(void){

  Wire.beginTransmission(0x62);   // I²C Adresse 

  Wire.write(0x05);               // Wähl Register-PWM aus   

  Wire.write(0x00);               //           

  Wire.endTransmission(); 

}

void PWMan(void){

  Wire.beginTransmission(0x62);   // I²C Adresse 

  Wire.write(0x05);               // Wähl Register-PWM aus   

  Wire.write(0x0E);               //            

  Wire.endTransmission();  

}

void PWMNULL(void){

  Wire.beginTransmission(0x62);   // I²C Adresse

  Wire.write(0x02);               // Wähl Register-PWM0 aus 

  Wire.write(0x00);               // Gibt Pulsweite vor für Ventilator 1           

  Wire.endTransmission(); 

  Wire.beginTransmission(0x62);   // I²C Adresse

  Wire.write(0x04);               // Wähl Register-PWM1 aus 

  Wire.write(0x00);               // Gibt Pulsweite vor für Ventilator 1           

  Wire.endTransmission();       

}

void IR_auswerten(void){

  // Fernbedienung  

  if (irrecv.decode(&results)){

    // Gibt decodierten Fernbedienungscode in Dezimal über Seriellen-Monitor aus

    Serial.println(results.value, DEC);

    // Vergleicht Result mit Vorgaben

    if (results.value == 3772797103 ) {PWMNULL(); PWMaus();}                                                              // PWM Auschalten      - Ferbedienung Taste

    if (results.value == 3772784863 ) {auswahl=0; standbye=0; }                                                           // Auswahl T1          - Ferbedienung Taste 1

    if (results.value == 3772817503 ) {auswahl=1; standbye=0; }                                                           // Auswahl T2          - Ferbedienung Taste 2

    if (results.value == 3772780783 ) {auswahl=2; standbye=0; PWMan();}                                                   // Stellgröße_manuel_1 - Ferbedienung Taste 4 

    if (results.value == 3772813423 ) {auswahl=3; standbye=0; PWMan();}                                                   // Stellgröße_manuel_2 - Ferbedienung Taste 5

    if (results.value == 3772788943 ) {auswahl=4; standbye=0; }                                                           // Sollwert            - Ferbedienung Taste 7

    if (results.value == 3772805263 ) {auswahl=5; standbye=1; PWMaus();}                                                  // Power-AUS           - Ferbedienung Taste POWER

    if (results.value == 3772831783 ) {man_auto=0; auto_stell =0.00; PWMNULL(); PWMan();}                                 // auf manuel schalten - Ferbedienung Taste bla

    if (results.value == 3772809343 ) {man_auto=1; man_stell_1=0.00; man_stell_2=0.00; PWMNULL(); PWMan(); resetPID();}   // auf PID_Regler schalten  schalten - Ferbedienung Taste bla

    if (results.value == 3772795063 ) {            // Stellgröße +1

      if(auswahl==2) man_stell_1++;                // Erhöt man_stell bei aufruf um 1  

      if(auswahl==3) man_stell_2++;

      if(auswahl==4) Sollwert++;                                                           

      if (man_stell_1 > 99) man_stell_1 = 99;      // Begrenzt Wert auf 99

      if (man_stell_2 > 99) man_stell_2 = 99;      // Begrenzt Wert auf 99

      if (Sollwert    < 99) Sollwert    = 99;      // Begrenzt Wert auf 99

    }

    if (results.value == 3772778743 ) {            // Stellgröße -1

      if(auswahl==2) man_stell_1--;                // Senkt man_stell bei aufruf um 1

      if(auswahl==3) man_stell_2--;

      if(auswahl==4) Sollwert--;                                 

      if (man_stell_1 < 0) man_stell_1 = 0;        // Begrenzt Wert auf 0

      if (man_stell_2 < 0) man_stell_2 = 0;        // Begrenzt Wert auf 0

      if (Sollwert    < 0) Sollwert    = 0;        // Begrenzt Wert auf 0

    }

    irrecv.resume();                                //Der nächste Wert soll vom IR-Empfänger eingelesen werden

  }

}

void luefterstellen(void){

  // LED steuerung Automatisch / Manuel

  if (man_auto == 1 && (int)temp_2 >= min_temp_ofen){ 

    digitalWrite(A3, HIGH);       // Schaltet LED ein (PID-Regler-AN)

  }

  else{

    digitalWrite(A3, LOW);        // Schaltet LED auz (PID-Regler-AUS)

  }

  // Autostellgröße skallieren und convertieren

  stell_auto = convert_to_byte_mapped(auto_stell);

  // Manuelestellgrößen skallieren und convertieren

  stell_manuel_1 = convert_to_byte_mapped(man_stell_1);

  stell_manuel_2 = convert_to_byte_mapped(man_stell_2);

  // Schaltet erst dazu wenn 20% Leistung benötigt wird  --> untere_schwelle = 20%

  if(stell_manuel_1 > untere_schwelle || stell_manuel_2 > untere_schwelle || stell_auto > untere_schwelle ){  

    // Manuelbetrieb

    // Überträgt nur neuen PWM Wert-Ventilator 1

    if(stell_manuel_1_alt != stell_manuel_1 && man_auto == 0 && standbye == 0) {

      set_value_luefter(pwm_ic,Luefter1,stell_manuel_1); 

    }

    // Überträgt nur neuen PWM Wert-Ventilator 2

    if(stell_manuel_2_alt != stell_manuel_2 && man_auto == 0 && standbye == 0) { 

      set_value_luefter(pwm_ic,Luefter2,stell_manuel_2);  

    }

    // Automatischer Betrieb

    // Überträgt nur neuen PWM Wert-Ventilator 1 und Ventilator 2

    if(stell_auto_alt != stell_auto && man_auto == 1 && standbye == 0){     

      set_value_luefter(pwm_ic,Luefter1,stell_auto); 

      set_value_luefter(pwm_ic,Luefter2,stell_auto);      

    }

    counter=0;

  }

  else{   

    // unter 20% bleibt Wert auf 0 wird nur einmal ausgeführt 

    // außer stellgröße war mal größer als untere_schwelle

    if(counter==0){

      PWMaus();

      counter++;

    }

  }

  // Speichert alte Werte

  stell_manuel_1_alt = stell_manuel_1;            

  stell_manuel_2_alt = stell_manuel_2;            

  stell_auto_alt     = stell_auto;                

}

void ini_io(void){

  for (int i=2;i<14;i++){     // Setzt Pins als Ausgänge 2-13

    pinMode(i,OUTPUT);

  }

  for (int i=2;i<14;i++){     // Grundeinstellung HIGH 2-13

    pinMode(i,HIGH);

  }

  pinMode(A3,OUTPUT);     // Setzt A3 als Ausgang

}

void ini_pca9533(void){

    // PWM-IC-config

  Wire.beginTransmission(0x62);  // Adresse

  Wire.write(0x11);              // Command - Auto-inc ON - Register 1 - PSC0 - Wahl

  Wire.write(0x00);              // Daten für PSC0 0-> PWM freq 145 HZ

  Wire.write(0x00);              // Daten für PWM0 0-> PEM 0% ON 

  Wire.write(0x00);              // Daten für PSC1 0-> PWM freq 145 HZ

  Wire.write(0x00);              // Daten für PWM2 0-> PEM 0% ON

  Wire.write(0x05);              // Daten für LS0-Register 0x0E -> LED0=PWM0 , LED2=PWM2 ,LED3=0, LED4=0

  Wire.endTransmission(); 

}

void ini_sev_seg(void){

  sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments, updateWithDelays, leadingZeros); // Setzt Segment Setting

  sevseg.setBrightness(90);

}

void set_value_luefter(byte adresse, byte reg, byte value){

    Wire.beginTransmission(adresse);                           // I²C Adresse 

    Wire.write(reg);                                       // Wähl Register-PWM1 aus   

    Wire.write(value);                             // Gibt Pulsweite vor  für Ventilator 2           

    Wire.endTransmission();  

}

void auswahl_fuer_display(){

  if (auswahl == 2 && man_auto == 0) sevseg.setNumber(man_stell_1, 2);     // Übergibt Manuelle Stellgröße an die 7-Seg_Anzeige

  if (auswahl == 3 && man_auto == 0) sevseg.setNumber(man_stell_2, 2);     // Übergibt Manuelle Stellgröße an die 7-Seg_Anzeige

  if (auswahl == 2 && man_auto == 1) sevseg.setNumber(auto_stell, 2);      // Übergibt Automatisch Stellgröße an die 7-Seg_Anzeige (PID_REGLER)

  if (auswahl == 3 && man_auto == 1) sevseg.setNumber(auto_stell, 2);      // Übergibt Automatisch Stellgröße an die 7-Seg_Anzeige (PID_REGLER)

  if (auswahl == 4)                  sevseg.setNumber(Sollwert, 2);        // Übergibt Sollwert

}

byte convert_to_byte_mapped(float value){

  int temp = (int)value;

  temp = map(temp, 0,99,0,255);

  return byte(temp);

}