Franzls Technik Forum

Code: Alles auswählen

// Arduino Pool_Solarheizung_Pumpensteuerung
#include <OneWire.h>
#include <DallasTemperature.h>
#include "Wire.h"
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);
//###########################################################################
//-------------------------------------MPPT Regler Deklaration---------------
/*************************************
   Für Uno wird SoftwareSerial benutzt
**************************************/
#include <SoftwareSerial.h>
SoftwareSerial tracerSerial(9, 8); // RO, DI  Pins drehen wenn nicht funktioniert
/**********************************************
    Ich verwende  einen MAX485-kompatiblen RS485-Transceiver.
  Rx/Tx ist mit der seriellen Schnittstelle der Hardware an "Serial" verbunden.
  Die Pins "Data Enable" und "Rec3eiver Enable" sind wie folgt beschaltet:
 ********************************************************/
#include <ModbusMaster.h>

#define MAX485_DE      7 // DE und RE dürfen am einen Pin hängen 
#define MAX485_RE_NEG  7

// instantiate ModbusMaster object
ModbusMaster node;

int prozent = 0;
float akkuVolt = 0;
float akkuAmpere = 0;
float pvwat = 0;
float pva = 0;
float pvv = 0;
unsigned long currentMillis = 0;

void preTransmission()
{
  digitalWrite(MAX485_RE_NEG, 1);
  digitalWrite(MAX485_DE, 1);
}

void postTransmission()
{
  digitalWrite(MAX485_RE_NEG, 0);
  digitalWrite(MAX485_DE, 0);
}
unsigned long previousMillis = 0;
const long intervall = 60000;// Daten werden alle 60 Sek ausgelesen
//------------------------------------MPPT Regler Deklaration Ende-----------
//###########################################################################
//-----Motortreiber----
const byte RPWM = 10;
const byte LPWM = 11;
//-------Potis---------
const byte Poti1 = A0;
const byte Poti2 = A1;
//-------Taster--------
byte Tasterstatur = 0;
const byte Taster = 4;// Display einschalten !!
//-------Merker--------
byte Pumpe = 0;
int P1 = 0;
int P2 = 0;
int Drehzahl = 0;
int Solldrehzahl = 0;
int Sollalt = 10;
byte Anfahren = 0;
int Drehzahlmin = 150;
int Drehzahlmax = 255;
unsigned long millisekunden = 0;
//-------------------------------Zeiten---------------------------------------
unsigned long Sekundenablauf01 = 0;      // Messung Potis und Ausgabe Display
const unsigned long Pausezeit01 = 1000;
unsigned long Sekundenablauf02 = 0;      // Display nach Zeit ausschalten
const unsigned long Pausezeit02 = 60000 * 15;
unsigned long Sekundenablauf03 = 0;      //Serial Werte Ausgabezeit
const unsigned long Pausezeit03 = 60000 * 5;
unsigned long Sekundenablauf04 = 0;      // Werte für Pumpe und Pumpe ansteuern
const unsigned long Pausezeit04 = 30000; //Alle 30 Sekunden Daten für Pumpe
const unsigned char One_Wire_Bus = 2;    // Sensoren auf Pin 2
OneWire oneWire(One_Wire_Bus);
DallasTemperature sensoren (&oneWire);
int Anzahl_Sensoren = 0;
int is = 0; // Zähler für die Sensoren
int ia = 0; // Zähler für die Adressstellen 0-7
int Sensor = 0;
float temppool = 0;
float tempsolar = 0;
float tempdif = 0;
DeviceAddress tempDeviceAddress; // Für die Adressausgabe
int numberOfDevices; // Für die Adressausgabe
//##########################################################################
//################################  Setup ##################################
//##########################################################################
void setup() {
  Wire.begin();
  sensoren.begin();
  Serial.begin(9600);
  lcd.begin();
  lcd.backlight();
  //##########################################################################
  //-----------------------------------MPPT Setup-----------------------------
  tracerSerial.begin(115200); // Modbus Kommunikation mit 115200 Baud
  pinMode(MAX485_RE_NEG, OUTPUT);
  pinMode(MAX485_DE, OUTPUT);
  digitalWrite(MAX485_RE_NEG, 0);// Init in receive mode
  digitalWrite(MAX485_DE, 0);
  // Tracer xxxxAN Modbus slave ID 1
  node.begin(1, tracerSerial);  // Begin der Verbindung mit Tracer
  // Rückrufe ermöglichen es uns, den RS485-Transceiver korrekt zu konfigurieren
  node.preTransmission(preTransmission);
  node.postTransmission(postTransmission);
  //-------------------------------MPPT Setup Ende--------------------------
  //##########################################################################
  lcd.setCursor (0, 0);
  lcd.print (F("Solarheizung - Pool"));
  lcd.setCursor (0, 1);
  lcd.print (F("Soll"));
  lcd.setCursor (10, 1);
  lcd.print (F("Ist"));
  lcd.setCursor (0, 2);
  lcd.print (F("Soll"));
  lcd.setCursor (10, 2);
  lcd.print (F("Ist"));
  lcd.setCursor (0, 3);
  lcd.print (F("Soll      Ist"));
  // Anzahl der Sesoren ermitteln-------------------------------------
  Anzahl_Sensoren = sensoren.getDeviceCount();
  // Ermitteln der Sensor-Adressen------------------------------------
  for (is = 0; is < Anzahl_Sensoren; is++)
  {
    if (sensoren.getAddress(tempDeviceAddress, is))
    {
      Serial.println ();
      printAddress(tempDeviceAddress);
    }
  }
  //-----------Aus-/Eingänge einrichten-------------------------------------
  pinMode(RPWM, OUTPUT);              // PWM Pumpensteuerung
  pinMode(LPWM, OUTPUT);              // PWM Pumpensteuerung
  pinMode(Poti1, INPUT);
  pinMode(Poti2, INPUT);
  pinMode(Taster, INPUT_PULLUP);
}
// Ausgabe der Sensor-Adressen
void printAddress(DeviceAddress deviceAddress)
{
  for (uint8_t ia = 0; ia < 8; ia++)
  {
    if (deviceAddress[ia] < 16)
    {
      Serial.print("0"); //ist die Hex Adresse kleiner 16 dann erste Stelle eine "0"
    }
    Serial.print(deviceAddress[ia], HEX);
  }
  Serial.println();
}
//###########################################################################
//################################## LOOP ###################################
//###########################################################################
void loop()
{
  millisekunden = millis();
  //--------------------------Display Lichtkontrolle -------------------------
  Tasterstatur = digitalRead(Taster);
  if (Tasterstatur == LOW)
  {
    lcd.backlight();
    Sekundenablauf02 = millisekunden;
  }
  if (millisekunden - Sekundenablauf02 >= Pausezeit02) // Dislay Zeit abgelaufen?
  {
    lcd.noBacklight();
  }
  //--------------------------Display Licht kontrolle Ende-------------------
  //#########################################################################
  //-------------------------Daten auswerten und aufs Display----------------
  if (millisekunden - Sekundenablauf01 >= Pausezeit01) // Eine Sekunde abgelaufen?
  {
    P1 = analogRead (Poti1);
    P1 = map(P1, 0, 1023, 0, 40); // -------Solltemperatur Einstellung-------
    P2 = analogRead (Poti2);
    P2 = map(P2, 0, 1023, 0, 10); // -------Solldiffderenz Einstellung-------
    lcd.setCursor (5, 1);
    lcd.print (P1);
    lcd.print (F("  "));
    lcd.setCursor (5, 2);
    lcd.print (P2);
    lcd.print (F("  "));
    lcd.setCursor (5, 3);
    lcd.print (Solldrehzahl);
    lcd.print (F("  "));
    lcd.setCursor (14, 3);
    lcd.print (Drehzahl);
    lcd.print (F("  "));
    Sekundenablauf01 = millisekunden;
    // -------------------------Temperatur Sensoren Auswerten---------------------------
    //Temperaturen Aulesen
    sensoren.requestTemperatures();

    // Hier werden die Temp-Sensoren ausgelesen und aufs Display gebracht
    if (Sensor < 2)
    {
      Sensor ++;
      float temperatur = sensoren.getTempCByIndex(Sensor - 1);
      if (Sensor == 1)
      {
        tempsolar = temperatur; // -----------Temperatur Messung 1------------------
      }
      if (Sensor == 2)
      {
        temppool = temperatur - 1; // -----------Temperatur Messung 2------------------
        //--------------------------------------Temperatur aufs Display----------------
        lcd.setCursor (14, 1);
        lcd.print (temppool);
        lcd.print (F(" "));
        tempdif = (tempsolar * 10) - (temppool * 10); //---Themperatur Differenz----
        if (tempdif < 0)
        {
          tempdif = 5;
        }
        lcd.setCursor (14, 2);
        lcd.print (tempdif / 10);
        lcd.print (F(" "));
      }
    }
    // ---Alle Sensoren ausgelesen? Dann für nächste Messungen auf Null Stellen---
    if (Sensor == Anzahl_Sensoren)
    {
      Sensor = 0;
    }
  }
  //-------------------------Daten auslesen und Aufs Diplay Ende------------------
  //##############################################################################
  // ------Daten für Pumpensteuerung auswerten und an Pumpe übergeben-------------

  if (millisekunden - Sekundenablauf04 >= Pausezeit04) // 30 Sekunden abgelaufen?
  {
    // -------Prüfen ob Solartemperatur zum Anlauf der Pumpe sinnvoll ist---------
    if ((tempsolar > 28) && (tempsolar < 33) && (tempdif < 10))
    {
      tempdif = 10;
    }
    if ((tempsolar < 26) && (tempdif < 10))
    {
      tempdif = 0;
    }
    //-------------Solldrehzahl aus Temperaturdifferenz ermitteln--------------
    Solldrehzahl = map(tempdif, 10, 40, 150, 255);
    if (Solldrehzahl > Drehzahlmax)
    {
      Solldrehzahl = Drehzahlmax;
    }
    else
    {
      if (Solldrehzahl < Drehzahlmin)
      {
        Solldrehzahl = Drehzahlmin;
      }
    }
    // Ist gemessene tempdif gleich/größer Solldifferenz, dann Max Drehzahl
    if (tempdif >= (P2 * 10))
    {
      Solldrehzahl = Drehzahlmax;
    }
    //------------------Pumpen Ansteuerung------------------------------------
    // Gibt es keine brauchbare TemperaturDifferenz mehr, dann Pumpe auf PWM 0
    if (Anfahren == 0)
    {
      if (tempdif < 10) //---Temp.Differenz kleiner 1 Grad, dann Pumpe aus----
      {
        Solldrehzahl = 0;
      }
      // Ist aber die Wunsch-Temperatur +2 erreicht, dann keine Solar Unterstützung mehr
      if (temppool > (P1 + 2))
      {
        Solldrehzahl = 0;
      }
      // Ist Solldrehzahl erreicht ? Dann Drehzahl auf die Solldrehzahl einstellen
      if (Solldrehzahl < Sollalt)
      {
        Drehzahl = Solldrehzahl;
        Sollalt = Solldrehzahl;
      }
    }
    // Ist Solldrehzahl nicht erreicht dann Drehzahl um 10 erhöhen
    if ((Solldrehzahl > Sollalt) && (tempdif > 13))
    {
      if (Drehzahl < 120)
      {
        Drehzahl = 130;
      }
      Drehzahl = Drehzahl + 10;
      // Wenn über Max, dann die Drehzahl auf Maxdrehzahl anpassen
      if (Drehzahl > Drehzahlmax)
      {
        Drehzahl = Drehzahlmax;
      }
      Sollalt = Drehzahl;
      Anfahren = 1;
    }
    else
    {
      Anfahren = 0;
    }
    if ((prozent <= 50) && (prozent > 0))
    {
      Drehzahl = 150;
    }
    if ((prozent <= 35) && (prozent > 0))
    {
      Drehzahl = 0;
    }
    if ((prozent > 60) && ((tempdif / 10) > P2))
    {
      Solldrehzahl = Drehzahlmax;
    }
    analogWrite(RPWM, Drehzahl);
    analogWrite(LPWM, 0);
    Sekundenablauf04 = millisekunden;
  }
  //------------------------Pumpensteuerung Ende-------------------------------
  //###########################################################################
  // ------------------------Serial Print Ausgabe------------------------------
  if (millisekunden - Sekundenablauf03 >= Pausezeit03) // Serial Ausgabezeit abgelaufen?
  {
    Serial.println("---------------------------------");
    Serial.print(F("Drehzahl Pumpe = "));
    Serial.print(Drehzahl);
    Serial.print(F("  soll = "));
    Serial.println(Solldrehzahl);
    Serial.print(F("Temp Pool = "));
    Serial.println(temppool);
    Serial.print(F("Temp Solar = "));
    Serial.println(tempsolar);
    Serial.print(F("Tempdif = "));
    Serial.print(tempsolar - temppool);
    Serial.print(F("  Soldif = "));
    Serial.println(P2);
    Serial.println("---------------------------------");
    Serial.print(F("Panel "));
    Serial.print(pvv);
    Serial.print(F("V  "));
    Serial.print(pva);
    Serial.print (F("A  "));
    Serial.print(pvwat);
    Serial.println(F("W"));
    Serial.print(F("Akku  "));
    Serial.print(akkuVolt);
    Serial.print (F("V  "));
    Serial.print(akkuAmpere);
    Serial.print(F("A  "));
    Serial.print(prozent);
    Serial.println (F("%"));
    Serial.println (F("---------------------------------"));
    Sekundenablauf03 = millisekunden;
  }
  //-------------------------Seriale Ausgabe Ende-----------------------------
  //##########################################################################
  //-------------------------------MPPT LOOP----------------------------------
  currentMillis = millis();
  if (currentMillis - previousMillis >= intervall)
  {
    previousMillis = currentMillis; // Zeitpunkt der letzten Schaltung wird festgehalten
    // Read 16 registers beginn mit Adresse  0x3100)
    uint8_t result;
    result = node.readInputRegisters(0x3100, 16);
    if (result == node.ku8MBSuccess)
    { //PV Daten
      pvv = node.getResponseBuffer(0x00) / 100.0f; //Tracer PV Volt
      pva = node.getResponseBuffer(0x01) / 100.0f;//PV Ampere
      //PV Leistung
      pvwat = ((node.getResponseBuffer(0x06) +  node.getResponseBuffer(0x07) ) / 100.0f);
      /*****  Akkustand Anzeigen  *****/
      akkuVolt = node.getResponseBuffer(0x04) / 100.0f; //Tracer Akku Volt
      akkuAmpere = node.getResponseBuffer(0x05) / 100.0f;//Akku Ladedaten in Ampere
    }
    result = node.readInputRegisters(0x311A , 1);//Akkukapazität in Prozent
    if (result == node.ku8MBSuccess) {
      prozent = node.getResponseBuffer(0x00);
    }
  }
  //-----------------------------MPPT LOOP Ende-------------------------------
  //##########################################################################
}