Ds18b20 Adresse vertauscht

Hallo. Habe an meinem Mega 2 ds18b20 an einem Pin angeschlossen. Jeder hat ja eine Adresse und einen von mir gegebenen Namen. Lief auch alles. Heute morgen als ich das Bord angeschlossen habe, Wurde temp1 von sensor2 und temp2 von Sensor1 angezeigt. Also genau falsch rum. Wurden nicht abgemacht und das ich die Sensoren durcheinander gebracht habe ist auch Ausgeschlossen. Habe an jedem ein Zettel ran gemacht mit der Nummer. Jemand ne Idee wie das Zustande gekommen ist?

Machst du getTempc() per Adresse oder per Index? Wenn man das per Adresse macht, dann ist egal in welcher Reihenfolge die Sensoren am Bus sind.

Hier mal der Code.

#include <OneWire.h>
#include <AFMotor.h>


#include <DallasTemperature.h>
#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h> 


#define ONE_WIRE_BUS 52 


OneWire oneWire(ONE_WIRE_BUS);

DallasTemperature sensors(&oneWire);

LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);



DeviceAddress Probe01 = { 0x28, 0xFF, 0x1B, 0x4B, 0x2E, 0x04, 0x00, 0x6B }; //1
DeviceAddress Probe02 = { 0x28, 0xFF, 0x1F, 0x76, 0x2B, 0x04, 0x00, 0x94 }; //2
//DeviceAddress Probe03 = { 0x28, 0x9A, 0x80, 0x40, 0x04, 0x00, 0x00, 0xD5 }; //3
//DeviceAddress Probe04 = { 0x28, 0x10, 0xA4, 0x57, 0x04, 0x00, 0x00, 0xA9 };//4

int rgb1r=40; // Hier die richtigen Pins eintragen
int rgb1g=41;
int rgb1b=42;
int rgb2r=43;
int rgb2g=44;
int rgb2b=45;

float Temperatur = 28.0; 
long previousMillis = 0;
long interval = 1000; 

AF_DCMotor Fan1(1, MOTOR12_64KHZ);
AF_DCMotor Fan2(2, MOTOR12_64KHZ);


void setup() 
{

  Fan1.setSpeed(255);
  Fan2.setSpeed(200);
  
  
sensors.begin();

sensors.setResolution(Probe01, 10);
sensors.setResolution(Probe02, 10);
// sensors.setResolution(Probe03, 10);
// sensors.setResolution(Probe04, 10);

pinMode(rgb1r, OUTPUT); 
pinMode(rgb1g, OUTPUT); 
pinMode(rgb1b, OUTPUT); 
pinMode(rgb2r, OUTPUT);
pinMode(rgb2g, OUTPUT); 
pinMode(rgb2b, OUTPUT); 

lcd.begin (20,4); 
lcd.backlight();
}


void loop() 
{
sensors.requestTemperatures(); 

if(sensors.getTempC(Probe01)>Temperatur+1){
Fan1.run(FORWARD);
digitalWrite(rgb1r,HIGH);
digitalWrite(rgb1g,LOW);
digitalWrite(rgb1b,LOW);
}else if(sensors.getTempC(Probe01)<Temperatur-1){
Fan1.run(RELEASE);
digitalWrite(rgb1b,HIGH);
digitalWrite(rgb1g,LOW);
digitalWrite(rgb1r,LOW);
}else{
digitalWrite(rgb1g,HIGH);
digitalWrite(rgb1r,LOW);
digitalWrite(rgb1b,LOW);
}
if(sensors.getTempC(Probe02)>Temperatur+0.5){
Fan2.run(FORWARD);
digitalWrite(rgb2r,HIGH);
digitalWrite(rgb2g,LOW);
digitalWrite(rgb2b,LOW);
}else if(sensors.getTempC(Probe02)<Temperatur-0.5){
Fan2.run(RELEASE);
digitalWrite(rgb2b,HIGH);
digitalWrite(rgb2g,LOW);
digitalWrite(rgb2r,LOW);
}else{
digitalWrite(rgb2g,HIGH);
digitalWrite(rgb2r,LOW);
digitalWrite(rgb2b,LOW);
}

unsigned long currentMillis = millis();
if(currentMillis - previousMillis > interval) {
previousMillis = currentMillis; 
lcd.clear(); 
lcd.home();
lcd.backlight(); 

lcd.setCursor(0,0); 
lcd.print(F("Becken1: "));
displayTemperature(Probe01);

lcd.setCursor(0,1); 
lcd.print(F("Becken2: "));
displayTemperature(Probe02);

// lcd.setCursor(0,2); 
// lcd.print("3: ");
// displayTemperature(Probe03);

// lcd.setCursor(0,3); 
// lcd.print("4: ");
// displayTemperature(Probe04);

}

}


void displayTemperature(DeviceAddress deviceAddress)
{

float tempC = sensors.getTempC(deviceAddress);

if (tempC == -127.00) 
{
lcd.print("Temperature Error");
}
else
{
lcd.print("C=");
lcd.print(tempC);

}
}

Hallo,

ich habe eine Vermutung.

Am Anfang definierst Du die Adressen mit eindeutigen Namen. DeviceAddress Probe01 = { 0x28, 0xFF, 0x1B, 0x4B, 0x2E, 0x04, 0x00, 0x6B }; //1 DeviceAddress Probe02 = { 0x28, 0xFF, 0x1F, 0x76, 0x2B, 0x04, 0x00, 0x94 }; //2

Und weiter unten rufst Du eine Funktion mit Wertübergabe void displayTemperature(DeviceAddress deviceAddress) { ...

Ich glaube hier könnte das Problem liegen, dass einfach ein irgendwas neues erzeugt wird und keiner weis was und es passiert zufälliges. Du erzeugst hier vermutlich eine neues leeres Device mit dem Namen deviceAddress. Solche unglücklichen Namensvergaben sind zudem immer blöd. Es kann nur mit dem großen und kleinen d/D am Anfang unterschieden werden. Andere klarere Namen wären besser. Zudem solltest Du eben hier nicht neu definieren, so meine VErmutung. Zudem Du am laufenden Band den Sensor abfragst. Frage die Sensoren am Anfang der loop ab, speichere den Wert in einer Variable und verwende dann für alles andere die Variable. Das geht auch schneller, weil das auslesen eines Dallas bis 750ms dauern kann. In der Zeit hat Dein µC schon zig tausend mal die loop neu durchlaufen.

Bsp. von mir

TempSensor1 = sensors.getTempC(sensor1);   // 1. Dallas Sensor auslesen (Device Adresse)
TempSensor2 = sensors.getTempC(sensor2);  // 2. Dallas Sensor auslesen

sind beides float Variablen.

lcd.setCursor (0,0);
lcd.print(TempSensor1);  // 1. DS18S20 
lcd.write(0xDF);                  //  ° Zeichen
lcd.print(F("C"));

als universelle Funktion könnte das dann so aussehen, die man zum Bsp. mit TempToDisplay(0, 0, TempSensor1); aufruft.

// Temperaturwerte auf Display ausgeben
void TempToDisplay(byte Spalte, byte Zeile, float temp)
{
  lcd.setCursor(Spalte,Zeile);
  lcd.print(temp);      //  Temp eines DS18S20 
  lcd.write(0xDF);      //  ° Zeichen
  lcd.print(F("C "));
}

probiere es aus und spiele damit rum ... :)

Doc_Arduino: Ich glaube hier könnte das Problem liegen, dass einfach ein irgendwas neues erzeugt wird und keiner weis was und es passiert zufälliges. Du erzeugst hier vermutlich eine neues leeres Device mit dem Namen deviceAddress.

C++ ist case sensitiv. Ist vielleicht etwas unglücklich benannt, aber es sollte theoretisch gehen. Wenn nicht würde der Compiler wahrscheinlich/hoffentlich wegen unpassenden Typen oder Variablen meckern.

DeviceAddress ist übrigens ein typedef auf "unsigned char DeviceAddress[8]". Das geht daher auch:

void func(unsigned char* address)
{
    sensors.getTempC(address);
}

Aber man kann es mal ändern. Ein Array aus DeviceAddresses und dann über den Index anspricht kann auch praktisch sein:

DeviceAddress sensorList[] = {
    { 0x28,0x68,0x2A,0xA4,0x05,0x00,0x00,0xAB },    
        { 0x28,0x82,0x38,0xA5,0x05,0x00,0x00,0x3D }
};
  lcd.write(0xDF);      //  ° Zeichen
  lcd.print(F("C "));

Du kannst auch sowas machen:

lcd.print(F("\DF" "C"));

Die Stückelung ist nötig weil er sonst nach versucht DFC als 16 Bit Hex zu parsen

Hallo,

ich glaube das funktioniert so nicht. Ich habe das jetzt nicht nochmal getestet, aber damals habe ich ausgiebig rumprobiert. Für die Zeichenausgabe ° benötigt man lcd.write. Mit lcd.print bekommt man nur Hexzahl als Dezimalzahl ausgeben, soweit ich mich erinnere.

Und lass ihn erstmal mit selbst definierten Adressnamen zum Erfolg kommen. Dann kann er immer noch mit Arrays hantieren, wenn es Sinn macht, falls noch mehr Sensoren dazukommen sollten.

War auch leicht falsch. Muss so sein:

lcd.print(F("\xDF" "C"));

Siehe String Escape Sequenzen: http://en.wikipedia.org/wiki/Escape_sequences_in_C#Table_of_escape_sequences

Rein theoretisch müsste es das gleiche sein. Sowas habe ich z.B. schon mit PROGMEM Font Definition gemacht, wo man > 127 ist, also außerhalb des regulären ASCII Satzes. Kann aber natürlich sein, dass print() das irgendwie anders interpretiert und man doch wirklich write() braucht