Arduino DS18B20 mit Relais Etc

Moin,

Ich habe mich jetzt schon seit zwei tagen festgebaggert und komme einfach nicht weiter ;/

Ich möchte die Rücklauftemperatur von unsere Heizung mit der Temperatur vom Pufferspeicher(Solaranlage und Ofen) und wenn der Puffer wärmer wie der Rücklauf ist soll das zonen Ventil aufgehen.

Also quasi eine ganz einfache Temperatur differenz schaltung.

TempRücklauf < TempPuffer = Pin 9 High
Quasi so :wink:

Kann mir einer von euch sagen was ich dem Arduino Sagen muss damit er genau Diese Zwei temperatur sensoren ausließt und vergleicht? Ich bin naja etwas überfordert.

0x28, 0xF8, 0x1F, 0xD0, 0x5, 0x0, 0x0, 0xEA Ist der Sensor vom Puffer
0x28, 0xD3, 0xC8, 0xE4, 0x5, 0x0, 0x0, 0xED Ist der Sensor vom Rücklauf

Ich hoffe ihr versteht was ich meine und könnt mir helfen.

Grüße Felix

Moin,

Hier noch mal der Code aber sobald ich versuche die Adressen von den Sensoren darein zu machen geht nichts mehr :confused:

#include <OneWire.h>
#include <DallasTemperature.h>

//Pin des OneWireBus
#define ONE_WIRE_BUS 8
//Genauigkeit der Temperaturmessung (9-12 Bit)
#define TEMPERATURE_PRECISION 12
//Pin des Relais
#define RELAIS_PIN 11 //Pin des Relais

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

int numberOfDevices; 
int varianceTemperature;
DeviceAddress temperaturSensorenAdressen[100];
float temperaturen[100];

void setup(void)
{
  Serial.begin(9600);
  sensors.begin();
  //Relais Pin definieren
  pinMode(RELAIS_PIN, OUTPUT);
  //Varianztemperatur als 0 definieren (nur für den ersten Durchlauf relevant)
  varianceTemperature = 0;
  numberOfDevices = sensors.getDeviceCount();
  
  Serial.print(numberOfDevices, DEC);
  Serial.println(" Devices gefunden.");
  
  Serial.print("Parasite power ist: "); 
  if (sensors.isParasitePowerMode()) Serial.println("ON");
  else Serial.println("OFF");
  
  for(int i = 0; i <= (numberOfDevices - 1); i++)
  {
    if((sensors.getAddress(temperaturSensorenAdressen[i], i)))
    {
      Serial.print("Setze Aufloesung an Sensor ");
      Serial.print(i);
      Serial.print(" auf ");
      Serial.print(TEMPERATURE_PRECISION);
      Serial.println(" Bit.");
      
      sensors.setResolution(temperaturSensorenAdressen[i], TEMPERATURE_PRECISION);
      
      Serial.print("Aufloesung tatsaechlich auf ");
      Serial.print(sensors.getResolution(temperaturSensorenAdressen[i]), DEC);
      Serial.println(" Bit.");
      
    } else {
      Serial.print("Konnte den Sensor an der Stelle ");
      Serial.print(i);
      Serial.println(" nicht finden.");
    }
  }
}

void loop(void)
{ 
  // call sensors.requestTemperatures() to issue a global temperature 
  // request to all devices on the bus
  Serial.print("Hole Temperaturen ... ");
  sensors.requestTemperatures(); // Send the command to get temperatures
  Serial.println("DONE");
  
  //Gebe Temperaturen aus
  for(int i = 0; i <= (numberOfDevices - 1); i++)
  {
    temperaturen[i] = sensors.getTempC(temperaturSensorenAdressen[i]);
    switch (i)
    {
      case 0: Serial.print("Temperatur am Pufferspeicher: "); break;
      case 1: Serial.print("Temperatur am Ruecklauf: "); break;
      default: Serial.print("Temperatur an nicht definiertem Punkt: "); break;
    }
    Serial.println(temperaturen[i]);
  }
  
  //Falls die Temperatur des Pufferspeichers 3° größer als die des Rücklaufs wird das Relais geschlossen, 
  //wenn es nur noch 1° größer ist wieder geöffnet
  //wenn der Pufferspeicher wärmer als 60° wird, wird das Relais geschlossen
  if((temperaturen[0] - temperaturen[1] + varianceTemperature) >= 3 || temperaturen[0] > 60) 
  {
    if(digitalRead(RELAIS_PIN) != HIGH)
    {
      digitalWrite(RELAIS_PIN, HIGH);
      varianceTemperature = 2;
      Serial.println("Schalte Relais an!");
    }
  }
  else
  {
    if(digitalRead(RELAIS_PIN) != LOW)
    {
      digitalWrite(RELAIS_PIN, LOW);
      varianceTemperature = 0;
      Serial.println("Schalte Relais aus!");
    }
  }
  delay(5000);
}

Hallo,

hast Du die Bsp. der Dallas Library angeschaut? Du ersetzt bestimmt ein Adress Array mit Deinen Adressen knall hart, was so nicht funktioniert.

Hab mal mein Code abgeändert, kompiliert aber ungetestet. Deine Sensor Adressen und Data Pin mußte anpassen, der Rest sollte laufen.

/* Sketch by Doc_Arduino from german Arduino Forum
   This is a modified "DallasTemperature" Library examples "WaitforConversion" without hard delay,
   for a best of speed.	   
   Arduino IDE vn 1.0.6
*/


#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into pin 2 on the Arduino
#define ONE_WIRE_BUS 2

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);

// change of your sensors adress or use "getTempCByIndex" and see below
DeviceAddress sensor1 = { 0x10, 0x40, 0xDD, 0xC3, 0x2, 0x8, 0x0, 0xB4 };
DeviceAddress sensor2 = { 0x10, 0x8A, 0xB, 0xAC, 0x2, 0x8, 0x0, 0x2C };

int resolution = 12;                      // DS18S20 only 9bit, other 9...12
unsigned long lastTempRequest = 800;      // start delay for first measurement
unsigned int  ConversionDelay = 800;      // default 750ms, okay for all DS1820 types
float temperature = 0.0;
boolean AllowDallasTempRequest = true;
float TempSensor1 = 0.0;                  // Zwischenspeicher zum auslesen
float TempSensor2 = 0.0;                  // Zwischenspeicher zum auslesen


void setup(void)
{
  Serial.begin(9600);
    
  sensors.begin();
  // set the resolution (Each Dallas/Maxim device is capable of several different resolutions)
  sensors.setResolution(sensor1, resolution);
  sensors.setResolution(sensor2, resolution);
  sensors.setWaitForConversion(false);        // makes it async
  // ConversationDelay = (ConversationDelay / (1 << (12-resoltion)));  // only use for DS18B20
}

void loop(void)
{ 
  
  // Request a temperature conversion 
  if ( AllowDallasTempRequest == true )
    {           
     sensors.requestTemperatures();
     AllowDallasTempRequest = false;
     lastTempRequest = millis(); 
    }
  
  // readout the Dallas sensors  
  if ( millis() - lastTempRequest >= ConversionDelay )  // waited long enough?
    {
     Serial.print(F("Sensor 1: ")); Serial.println(sensors.getTempC(sensor1));  
     Serial.print(F("Sensor 2: ")); Serial.println(sensors.getTempC(sensor2));     
     Serial.print(F("Differenz: ")); Serial.println(sensor2-sensor1);   
     AllowDallasTempRequest = true;
    }
  
  // *** does other things *** //
  
}

Moin,

Vielen Dank für deine Hilfestellung :wink:
Jetzt kann ich den Code schonmal compilieren aallerdings bleiben die Temperatur werte konstant so…
Zu Dem Code ist noch ein funktionierender hinzu gekommen welcher alleridngs alleine Ohne Probleme lief .

Hier der Code

/* Sketch by Doc_Arduino from german Arduino Forum
   This is a modified "DallasTemperature" Library examples "WaitforConversion" without hard delay,
   for a best of speed.	   
   Arduino IDE vn 1.0.6
*/
/* Erster Versuch Mischersteuerung  20101025 mb[ALT-Q]komputer.de   
Die delays durch millis ersetzt von Berry07*/
#include <OneWire.h>
#include <DallasTemperature.h>
// DS1820 an PIN 2
#define ONE_WIRE_BUS 8
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
#define Mischer_AUF 9
#define Mischer_ZU 10
#define Zonenventil_PIN 11 //Pin des Relais
/********************************************************************************/
// Solltemperatur
int tempsoll = 55;
//DeviceAdressen der einzelnen ds1820 Temperatursensoren angeben. (loop anpassen)
DeviceAddress sensor0 = { 0x28, 0xF8, 0x1F, 0xD0, 0x5, 0x0, 0x0, 0xEA };
DeviceAddress sensor1 = { 0x28, 0x6B, 0x8E, 0xCF, 0x5, 0x0, 0x0, 0xDA };
DeviceAddress sensor2 = { 0x28, 0xEF, 0xC4, 0xCF, 0x5, 0x0, 0x0, 0xB8 };
DeviceAddress sensor3 = { 0x28, 0xD3, 0xC8, 0xE4, 0x5, 0x0, 0x0, 0xED };
DeviceAddress sensor4 = { 0x28, 0xEE, 0xC7, 0xE4, 0x5, 0x0, 0x0, 0x25 };
 
 
int resolution = 12;                      // DS18S20 only 9bit, other 9...12
unsigned long lastTempRequest = 800;      // start delay for first measurement
unsigned int  ConversionDelay = 800;      // default 750ms, okay for all DS1820 types
float temperature = 0.0;
boolean AllowDallasTempRequest = true;

float TempSensor0 = 0.0;                  // Zwischenspeicher zum auslesen
float TempSensor1 = 0.0;                  // Zwischenspeicher zum auslesen 
float TempSensor2 = 0.0;                  // Zwischenspeicher zum auslesen 
float TempSensor3 = 0.0;                  // Zwischenspeicher zum auslesen 
float TempSensor4 = 0.0;                  // Zwischenspeicher zum auslesen 
//char sensor0Name[] = "PufferOben: ";
//char sensor1Name[] = "PufferMitte: ";
//char sensor2Name[] = "PufferUnten: ";
//char sensor3Name[] = "GeimeinsamerRucklauf: ";
//char sensor4Name[] = "Rucklaufanhebung: ";
// Hysterese
int hyst = 2;
int varianceTemperature;
unsigned long MischenA;    
unsigned long WartenA,WartenB;
/********************************************************************************/
void setup() {                
  pinMode(Mischer_AUF, OUTPUT); 
  pinMode(Mischer_ZU, OUTPUT); 
  pinMode(Zonenventil_PIN, OUTPUT);
  digitalWrite(Mischer_AUF, LOW);
  digitalWrite(Mischer_ZU, LOW);
  Serial.begin(9600);
    sensors.begin();  
  sensors.setResolution(sensor0, resolution);
  sensors.setResolution(sensor1, resolution);
  sensors.setResolution(sensor2, resolution);
  sensors.setResolution(sensor3, resolution);
  sensors.setResolution(sensor4, resolution);  
  sensors.setWaitForConversion(false);  
  varianceTemperature = 0;
}
/********************************************************************************/
void loop() {
 { 
  
  // Request a temperature conversion 
  if ( AllowDallasTempRequest == true )
    {           
     sensors.requestTemperatures();
     AllowDallasTempRequest = false;
     lastTempRequest = millis(); 
    }
  
  // readout the Dallas sensors  
  if ( millis() - lastTempRequest >= ConversionDelay )  // waited long enough?
    
     Serial.print(F("Sensor0: ")); Serial.println(sensors.getTempC(sensor0));  
     Serial.print(F("Sensor1: ")); Serial.println(sensors.getTempC(sensor1));   
     Serial.print(F("Sensor2: ")); Serial.println(sensors.getTempC(sensor2));   
     Serial.print(F("Sensor3: ")); Serial.println(sensors.getTempC(sensor3));   
     Serial.print(F("Sensor4: ")); Serial.println(sensors.getTempC(sensor4));     
   
     AllowDallasTempRequest = true;
    }
  
 
 
  (sensors.getTempC(sensor0));
  int tempist = sensors.getTempC(sensor0);
  Serial.print("Ist Temp: ");
  Serial.println(tempist);
  //------> MISCHEN Anfang
  WartenA = millis();    //alles 10 Sekunden die Temperaturen vergleichen
       if (WartenA - WartenB > 10000){
          if (tempist > (tempsoll + hyst)) {    // Mischer zu - Temperatur runter
             MischenA = millis();    
            while (millis() - MischenA < ((tempist - tempsoll) * 500)) {  
                //z.B.tempist=27(Grad) und tempsoll= 22(Grad) dann geht der Mischer 5*500ms also 2,5sec lang zu  
                digitalWrite(Mischer_ZU, HIGH);
                Serial.print("Mischzeit ist ");
                Serial.println(((tempist - tempsoll) * 500));
                Serial.println("Mischer faehrt ZU");
             }
                digitalWrite(Mischer_ZU, LOW);
           }
          if (tempist < (tempsoll - hyst)) {    // Mischer auf - Temperatur erhoehen 
             MischenA = millis();    
            while (millis() - MischenA < ((tempsoll - tempist) * 500)) {    
                digitalWrite(Mischer_AUF, HIGH);
                Serial.print("Mischzeit ist ");
                Serial.println(((tempsoll - tempist) * 500));
                Serial.println("Mischer faehrt AUF");
             }
                digitalWrite(Mischer_AUF, LOW);
           }
          WartenB = millis();  
       } //--------MISCHEN Ende-----------------
  
  //Falls die Temperatur des Pufferspeichers 3° größer als die des Rücklaufs wird das Relais geschlossen, 
  //wenn es nur noch 1° größer ist wieder geöffnet
  //wenn der Pufferspeicher wärmer als 60° wird, wird das Relais geschlossen
  if((sensor0 - sensor3 + varianceTemperature) >= 3 )
  {
    if(digitalRead(Zonenventil_PIN) != HIGH)
    {
      digitalWrite(Zonenventil_PIN, HIGH);
      varianceTemperature = 2;
      Serial.println("Schalte Relais an!");
    }
  }
  else
  {
    if(digitalRead(Zonenventil_PIN) != LOW)
    {
      digitalWrite(Zonenventil_PIN, LOW);
      varianceTemperature = 0;
      Serial.println("Schalte Relais aus!");
    }
  }
  

 }

Grüße Felix derjetztschonmaletwasmehrversteht :slight_smile:

Hallo,

funktioniert denn mein Bsp. Code mit Deinen Sensoradressen usw.? Oder bleiben auch hier die Werte konstant?
Vorher brauchen wir nicht weiter machen.

Moin,

Sorry hatte ich vergessen zu erwähnen dein Beispielcode arbeitet und gibt mir die Werte über den Seriellen Monitor aus.

Grüße Felix

Hallo,

oh mein Gott. Du kannst froh sein das Dein Code kompiliert wird. Aber durch falsche Klammersetzung und wildes Code kopieren macht er nicht das was er soll.

// readout the Dallas sensors  
  if ( millis() - lastTempRequest >= ConversionDelay )  // waited long enough?
    
     Serial.print(F("Sensor0: ")); Serial.println(sensors.getTempC(sensor0));  
     Serial.print(F("Sensor1: ")); Serial.println(sensors.getTempC(sensor1));   
     Serial.print(F("Sensor2: ")); Serial.println(sensors.getTempC(sensor2));   
     Serial.print(F("Sensor3: ")); Serial.println(sensors.getTempC(sensor3));   
     Serial.print(F("Sensor4: ")); Serial.println(sensors.getTempC(sensor4));     
   
     AllowDallasTempRequest = true;
     }

normalerweise müßte der Compiler hier schon meckern, weil eine geschweifte Klammer fehlt und wenn die IF Anweisung überhaupt etwas macht, dann nur die erste nachfolgende Zeile.

Dann folgt solcher Bockmist wie der hier.

(sensors.getTempC(sensor0));
  int tempist = sensors.getTempC(sensor0);

erstens wird der Sensor ausgelesen ohne das es was bringt, weil der Wert nirgends zugewiesen wird.
Zweitens wird zwar einer Variablen zugewiesen, da diese aber Ganzzahlig ist, fehlen dir die Kommastellen.

Außerdem wird durch dieses wilde Code kopieren der Sensor bis hier schon 3x hintereinander ausgelesen was nicht sein sollte. Du bekommst also zwangsläufig immer den alten Werte solange kein neuer Request gestartet wird.

Du mußt aller 800ms die Sensoren auslesen und in einer Variablen speichern. Danach verwendest Du nur noch die Variablen im weiteren Code. Du mußt nicht jedesmal den Sensor direkt neu auslesen. Macht bei mindestens 750ms auch keinen Sinn wegen der Wartezeit.

Der reine Auslesecode sollte so aussehen, den Rest machst Du nur noch mit dem Variablen.

// readout the Dallas sensors  
  if ( millis() - lastTempRequest >= ConversionDelay )  // waited long enough?
    {
     TempSensor0 = sensors.getTempC(sensor0);  
     TempSensor1 = sensors.getTempC(sensor1);     
	 TempSensor2 = sensors.getTempC(sensor2); 
	 TempSensor3 = sensors.getTempC(sensor3); 
	 TempSensor4 = sensors.getTempC(sensor4); 
     AllowDallasTempRequest = true;
    }

Mein Tipp. Fang langsam an, verstehe jeden Codeblock, teste einzeln. Wenn Du alles nur zusammen würfelst kommt zwangläufig Müll raus.

Ich habe das Auslesen bei mir eine Funktion ausgelagert. Die Funktion liefert einen bool zurück wenn neue Temperatur-Werte ausgelesen wurden. Darauf kann man dann abfragen und auch nur dann was mit den Werten machen.

Hallo,

er sollte erstmal den Code verstehen und zum laufen bekommen. Dann kann er immer noch optimieren.

Moin,

Vielen Dank für eure Gedult mit mir :slight_smile:
ich habe jetzt erstmal alles soweit gekürzt bis nurnoch alles ausgelesen wird.
Eine frage wie kann ich jetzt diese Variable auslesen bzw nutzen?

Ich hoffe ich stelle mich nicht zu doof an :confused:

/* Sketch by Doc_Arduino from german Arduino Forum
   This is a modified "DallasTemperature" Library examples "WaitforConversion" without hard delay,
   for a best of speed.	   
   Arduino IDE vn 1.0.6
*/

#include <OneWire.h>
#include <DallasTemperature.h>
// DS1820 an PIN 8
#define ONE_WIRE_BUS 8
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
#define Mischer_AUF 9
#define Mischer_ZU 10
#define Zonenventil_PIN 11
/********************************************************************************/
// Solltemperatur
//int tempsoll = 55;
//DeviceAdressen der einzelnen ds1820 Temperatursensoren angeben. (loop anpassen)
DeviceAddress sensor0 = { 0x28, 0xF8, 0x1F, 0xD0, 0x5, 0x0, 0x0, 0xEA };
DeviceAddress sensor1 = { 0x28, 0x6B, 0x8E, 0xCF, 0x5, 0x0, 0x0, 0xDA };
DeviceAddress sensor2 = { 0x28, 0xEF, 0xC4, 0xCF, 0x5, 0x0, 0x0, 0xB8 };
DeviceAddress sensor3 = { 0x28, 0xD3, 0xC8, 0xE4, 0x5, 0x0, 0x0, 0xED };
DeviceAddress sensor4 = { 0x28, 0xEE, 0xC7, 0xE4, 0x5, 0x0, 0x0, 0x25 };
 
 
int resolution = 12;                      // DS18S20 only 9bit, other 9...12
unsigned long lastTempRequest = 800;      // start delay for first measurement
unsigned int  ConversionDelay = 800;      // default 750ms, okay for all DS1820 types
float temperature = 0.0;
boolean AllowDallasTempRequest = true;

float TempSensor0 = 0.0;                  // Zwischenspeicher zum auslesen
float TempSensor1 = 0.0;                  // Zwischenspeicher zum auslesen 
float TempSensor2 = 0.0;                  // Zwischenspeicher zum auslesen 
float TempSensor3 = 0.0;                  // Zwischenspeicher zum auslesen 
float TempSensor4 = 0.0;                  // Zwischenspeicher zum auslesen 
//char sensor0 = PufferOben
//char sensor1 = PufferMitte
//char sensor2 = PufferUnten
//char sensor3 = GeimeinsamerRucklauf
//char sensor4 = Rucklaufanhebung
// Hysterese
int hyst = 2;
int varianceTemperature;
unsigned long MischenA;    
unsigned long WartenA,WartenB;
/********************************************************************************/
void setup() {                
//  pinMode(Mischer_AUF, OUTPUT); 
//  pinMode(Mischer_ZU, OUTPUT); 
//  pinMode(Zonenventil_PIN, OUTPUT);
 // digitalWrite(Mischer_AUF, LOW);
 // digitalWrite(Mischer_ZU, LOW);
  Serial.begin(9600);
    sensors.begin();  
  sensors.setResolution(sensor0, resolution);
  sensors.setResolution(sensor1, resolution);
  sensors.setResolution(sensor2, resolution);
  sensors.setResolution(sensor3, resolution);
  sensors.setResolution(sensor4, resolution);  
  sensors.setWaitForConversion(false);  
 // varianceTemperature = 0;
}
/********************************************************************************/
void loop() {

 // readout the Dallas sensors  
  if ( millis() - lastTempRequest >= ConversionDelay )  // waited long enough?
    
     Serial.print(F("Sensor0: ")); Serial.println(sensors.getTempC(sensor0));  
     Serial.print(F("Sensor1: ")); Serial.println(sensors.getTempC(sensor1));   
     Serial.print(F("Sensor2: ")); Serial.println(sensors.getTempC(sensor2));   
     Serial.print(F("Sensor3: ")); Serial.println(sensors.getTempC(sensor3));   
     Serial.print(F("Sensor4: ")); Serial.println(sensors.getTempC(sensor4));     
   
     AllowDallasTempRequest = true;
     }


[Code]


Grüße Felix

Hallo,

wenn ich das so sehe, denke ich, Du weist nicht was eine Variable ist und was 2 ineinander gefügte Funktionen sind.

Wenn Du das Grundgerüst mit der seriellen Ausgabe verstanden hast und das letzte mit der Variablen Zuweisung, dann wäre es jetzt nur noch ein kleiner Schritt um alle 5 Sensoren in eine Variable auszulesen und dann die Variable seriell ausgeben zu lassen.