search

RobTillaart / SHT85

Arduino library for the SHT85 temperature and humidity sensor
MIT License
11 stars 4 forks source link

Set the Heater on , 8x SHT85 with a TCA 9548 Multiplexer #25

Closed BenjaminBernhardt closed 9 months ago

BenjaminBernhardt commented 9 months ago

I can start the Heater if the Switch is HIGH at the First Startup. The Temperature of Sensor 1 rises. All the other Sensors doesnt rise the Temperature. If I switch off the Switch (Input 12) and turn it on after 180 seconds all sensors doesnt heat, also the Sensor 1.

Maybe you can help me with this.

Thank you

Code:

// Adafruit Feather M4 CAN
// SHT85 Temp. und Luftf. Sensor mit I²C Multiplexer
// Daten senden über CAN 2.0A 500kbit/s
// Version 1.0:              -Datenübermittlung per CAN-Bus.
// Version 1.1:   6.12.2023  -Abfrage ob die Sensoren angeschlossen sind wurde über build in LED hinzugefügt (Ausgang 13).
//                           -0x00 Datenpackete werden gesendet wenn kein Sensor angeschlossen.
//                            ist (vorher stand der letzte gemessene Wert im Speicher) 
//                           -Durchgangsdauer eingefügt.
// Version 1.2:   8.12.2023  -I²C Multiplexer TCA9548 eingebunden um die möglichkeit zu bieten, bis zu acht Sensoren mit-
//                            identischer Adresse (SHT85=0x44) auf einem I²C-BUS laufen zu lassen.
// Version 1.3:   14.12.2023 -Pin 12 (Schalter für die Heizung) initialisiert (noch nicht eingebunden).
//                           -CAN-Bus Datenübermittelung und auslesen der Sensoren 3-8 eingefügt. Adressen angepasst
//                            (2020=Sensor1 bis 2027=Sensor8).

// INFO!  Es muss noch ein WDT (Watchdog) eingefügt werden, damit bei einem Fehler automatisch neu gestartet wird.

// Benjamin Bernhardt
//-----------------------------------------------------------------------------------------------------------------------

// Bibliotheken einfügen:
#include <Arduino.h>    //Arduino Standard-Bibliothek
#include <SHT85.h>      //SHT-85 Bibliothek
#include <TCA9548.h>    //I2C Multiplexer Bibliothek  
#include <CANSAME5x.h>  //CAN-Bus Bibliothek

// Benennung des CAN-Modules
CANSAME5x CAN;

// I²C Multiplexeradresse
TCA9548 MP(0x70);

// Sensoradresse (Der SHT85 Sensor besitzt nur eine ID (0x44).
// Deshalb braucht man den I²C Multiplexer um die Sensoren auf den Bus zu legen und auch wieder herunter zu nehmen). 
#define SHT85_ADDRESS   0x44

// Sensorname ist SHT85
SHT85 sht;

// Stoppuhr Variablen
unsigned long previousMillis = 0; // Anfangsmesspunkt der Zeit
unsigned long elapsedMillis = 0;  // Endmesspunkt der Zeit

int Messgeschwindigkeit = false;   // default = true/fast       slow = false
int HeizungsSchalter = 12;
int SchalterStatus = 0;
int Error;
//-----------------------------------------------------------------------------------------------------------------------

void setup()
{
  // PIN-Modus der Arduino Ein/Ausgänge
  pinMode(PIN_CAN_STANDBY, OUTPUT);
  digitalWrite(PIN_CAN_STANDBY, false); // turn off STANDBY

  pinMode(PIN_CAN_BOOSTEN, OUTPUT);
  digitalWrite(PIN_CAN_BOOSTEN, true); // turn on booster

  pinMode(13, OUTPUT);
  pinMode(12, INPUT);

  // Konsole starten mit 9600 Baud
  Serial.begin(9600);

  //Zeit für die initiierung des seriellen Monitors
  //delay(3000);

  //Serial.print("Konsole gestartet\n");
  Serial.println("SHT85-Box Version 1.3");
  Serial.print("SHT85_LIB_VERSION: ");
  Serial.println(SHT85_LIB_VERSION);
  Serial.print("TCA9548_LIB_VERSION: ");
  Serial.println(TCA9548_LIB_VERSION);
  Serial.print("proudly presented by Benjamin Bernhardt\n\n");
  //delay(3000); // let serial console settle

  // Initiieren des I2C-Multiplexers
  Wire.begin();
  if (MP.begin() == true)
  {
    Serial.println("I2C-Multiplexer erkannt");
  }
  else
  {
    Serial.println("!I2C-Multiplexer ERROR!");
  }

  Serial.print("MASK:\t");
  Serial.println(MP.getChannelMask(), HEX);
  for (int chan = 0; chan < 8; chan++)
  {
    Serial.print("PRE:\t");
    Serial.print(MP.isEnabled(chan));
    MP.enableChannel(chan);
    Serial.print("\t");
    Serial.println(MP.isEnabled(chan));
    delay(100);
  }
  Serial.println();
  MP.setChannelMask(0x00);

  Serial.print("MASK:\t");
  Serial.println(MP.getChannelMask(), HEX);
  for (int chan = 0; chan < 8; chan++)
  {
    MP.enableChannel(chan);

    Serial.print("MASK:\t");
    Serial.println(MP.getChannelMask(), HEX);
    delay(100);
  }
  for (int chan = 0; chan < 8; chan++)
  {
    MP.disableChannel(chan);
    Serial.print("MASK:\t");
    Serial.println(MP.getChannelMask(), HEX);
    delay(100);
  }
  Serial.println();

  Serial.println("I²C Multiplexer eingestellt");

  // Initiieren der Sensorik
  //sht.begin(SHT85_ADDRESS);
  //if (sht.isConnected())
    //Serial.println("SHT85 erfolgreich initiiert");

  //Testweise
   //  initialize 4 SHT85's
  for (int channel = 0; channel < 8; channel++)
  {
    Serial.print(channel);
    MP.selectChannel(channel);  //  rotate over all SHT85's
    if (sht.begin() == false)
    {
      Serial.println("\tconnect error.");;
    }
    else 
    {
      Serial.println("\tOK!.");;
    }
    delay(10);

  // Maximale Laufzeit der internen Heizung in Sekunden
  sht.setHeatTimeout(120);

  // CAN-Bus auf 500kbit/s
  if (!CAN.begin(500000)) {
    Serial.println("!CAN-Bus auf 500kbit/s nicht gestartet!");
    while (1) delay(10);
  }
  Serial.println("CAN-Bus auf 500kbit/s erfolgreich initiiert");

  // Ausgabe über den seriellen Monitor
  Serial.print("Bootvorgang abgeschlossen \n\n\n");

  // Zeit zum lesen da der Bootvorgang ansonsten zu schnell ist
  //delay(5000);  
}
}
void loop() {
//-----------------------------------------------------------------------------------------------------------------------
  // Stoppuhr start
  previousMillis = millis();
//-----------------------------------------------------------------------------------------------------------------------  
  // Sensor1:
  // starten des I²C-Multiplexer auf Sensor1=Adresse0
  MP.enableChannel(0);
  MP.selectChannel(0);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));

  // Ausgabe über den seriellen Monitor
  Serial.print("Luftfeuchtigkeitssensor 1\n");

  //Abfrage des HeizungsSchalter
      SchalterStatus=digitalRead(HeizungsSchalter);
      Serial.println(SchalterStatus);
      Serial.println(sht.getError());

  //Heizung einschalten
  int getError(); //eventuelle Fehler des SHT85 zurücksetzen
  if (digitalRead(HeizungsSchalter) == 1) 
    sht.heatOn();
  else
    sht.heatOff();
  //delay(1);//Reaktionszeit abwarten

  // Abfrage Heizung
  if (sht.heatOn() == 1)
    Serial.print("Heizung Sensor 1 An!!! \n");
   else
   Serial.println(sht.heatOff());

  // auslesen von Sensor1
  sht.read(Messgeschwindigkeit);         // default = true/fast       slow = false

  // Wenn Sensor1 angeschlossen ist
  if (sht.read() == true) {

    // Statusleuchte 13 AN
    digitalWrite(13, HIGH);

    // serieller Monitor Sensor1
    Serial.print("\t");
    Serial.print(sht.getTemperature(), 2);
    Serial.print(" °C");
    Serial.print("\t");
    Serial.print(sht.getHumidity(), 2);
    Serial.println(" %RH");
    Serial.println();   //Leerzeile

    //Zwischenspeichern für den CAN-Bus Sensor1
    float Temp1 = sht.getTemperature();
    float Hum1 = sht.getHumidity();

    //Umwandeln in ein Byte
    byte* Temp1HEX = (byte*)&Temp1;
    byte* Hum1HEX = (byte*)&Hum1;

    // send packet: id is 11 bits, packet can contain up to 8 bytes of data
        //Serial.print("Sending packet ... ");
    CAN.beginPacket(0x7E4);    // Start der CAN-Bus-Nachricht auf Adresse 0x7E4 (Wert in Dezimal=2020)
    CAN.write(Temp1HEX, HEX);  // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.write(Hum1HEX, HEX);   // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.endPacket();           // Ende der CAN-Bus-Nachricht 
        //Serial.println("done");

    // Statusleuchte 13 AUS
    digitalWrite(13, LOW);

    //Datenübertragung des I²C-Bus auf Kanal 1 (Adresse 0) beenden
     MP.disableChannel(0);
        //Serial.print("MP-Kanal 1:");
        //Serial.println(MP.isEnabled(0));
        //Serial.print("MP-Kanal 2:");
        //Serial.println(MP.isEnabled(1));
  }
  // Wenn Sennsor1 nicht angeschlossen ist
  else {
    // Ausgabe über den seriellen Monitor
    Serial.println("kein Sensor1 angeschlossen");

    // Den Speicher des CAN-Bus für Sensor1 auf null setzten
    CAN.beginPacket(0x7E4);   // Start der CAN-Bus-Nachricht auf Adresse 0x7E4 (Wert in Dezimal=2020)
    CAN.write(0x00);          // Byte0 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte1 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte2 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte3 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte4 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte5 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte6 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte7 zurücksetzen (Wert in Dezimal=0)
    CAN.endPacket();          // Ende der CAN-Bus-Nachricht

  //Datenübertragung des I²C-Bus auf Kanal 1 (Adresse 0) beenden
  MP.disableChannel(0);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));
  }
//-----------------------------------------------------------------------------------------------------------------------  
  // Sensor2:
  // starten des I²C-Multiplexer auf Sensor2=Adresse1
  MP.enableChannel(1);
  MP.selectChannel(1);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));

  // Ausgabe über den seriellen Monitor
  Serial.print("Luftfeuchtigkeitssensor 2\n");

  //Heizung einschalten
  int getError(); //eventuelle Fehler des SHT85 zurücksetzen
  if (digitalRead(HeizungsSchalter) == 1) 
    sht.heatOn();
  else
    sht.heatOff();
        //delay(1);//Reaktionszeit abwarten

  // Abfrage Heizung Sensor2
  if (sht.isHeaterOn() == 1)
    Serial.print("Heizung Sensor 2 An \n");

  // auslesen von Sensor2
  sht.read(Messgeschwindigkeit);         // default = true/fast       slow = false

  // Wenn Sensor2 angeschlossen ist
  if (sht.read() == true) {

    // Statusleuchte 13 AN
    digitalWrite(13, HIGH);

    // serieller Monitor Sensor2
    Serial.print("\t");
    Serial.print(sht.getTemperature(), 2);
    Serial.print(" °C");
    Serial.print("\t");
    Serial.print(sht.getHumidity(), 2);
    Serial.println(" %RH");
    Serial.println();   //Leerzeile

    // Zwischenspeichern für den CAN-Bus Sensor2
    float Temp2 = sht.getTemperature();
    float Hum2 = sht.getHumidity();

    //Umwandeln in ein Byte
    byte* Temp2HEX = (byte*)&Temp2;
    byte* Hum2HEX = (byte*)&Hum2;

    // send packet: id is 11 bits, packet can contain up to 8 bytes of data
    //Serial.print("Sending packet ... ");
    CAN.beginPacket(0x7E5);       // Start der CAN-Bus-Nachricht auf Adresse 0x7E5 (Wert in Dezimal=2021)
    CAN.write(Temp2HEX, HEX);     // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.write(Hum2HEX, HEX);      // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.endPacket();              // Ende der CAN-Bus-Nachricht
    //Serial.println("done");

    // Statusleuchte 13 AUS
    digitalWrite(13, LOW);

    //Datenübertragung des I²C-Bus auf Kanal 2 (Adresse 1) beenden
    MP.disableChannel(1);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));   
  }
  // Wenn Sensor2 nicht angeschlossen ist
  else {
    //Ausgabe über den seriellen Monitor
    Serial.println("kein Sensor2 angeschlossen");

    // Den Speicher des CAN-Bus für Sensor2 auf null setzten
    CAN.beginPacket(0x7E5);   // Start der CAN-Bus-Nachricht auf Adresse 0x7E5 (Wert in Dezimal=2021)
    CAN.write(0x00);          // Byte0 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte1 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte2 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte3 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte4 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte5 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte6 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte7 zurücksetzen (Wert in Dezimal=0)
    CAN.endPacket();          // Ende der CAN-Bus-Nachricht 

    //Datenübertragung des I²C-Bus auf Kanal 2 (Adresse 1) beenden
    MP.disableChannel(1);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));
  }
//-----------------------------------------------------------------------------------------------------------------------  
    // Sensor3:
  // starten des I²C-Multiplexer auf Sensor3=Adresse2
  MP.enableChannel(2);
  MP.selectChannel(2);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));

  // Ausgabe über den seriellen Monitor
  Serial.print("Luftfeuchtigkeitssensor 3\n");

  //Heizung einschalten
  int getError(); //eventuelle Fehler des SHT85 zurücksetzen
  if (digitalRead(HeizungsSchalter) == 1) 
    sht.heatOn();
  else
    sht.heatOff();
        //delay(1);//Reaktionszeit abwarten

  // Abfrage Heizung Sensor3
  if (sht.isHeaterOn() == 1)
    Serial.print("Heizung Sensor 3 An \n");

  // auslesen von Sensor3
  sht.read(Messgeschwindigkeit);         // default = true/fast       slow = false

  // Wenn Sensor3 angeschlossen ist
  if (sht.read() == true) {

    // Statusleuchte 13 AN
    digitalWrite(13, HIGH);

    // serieller Monitor Sensor3
    Serial.print("\t");
    Serial.print(sht.getTemperature(), 2);
    Serial.print(" °C");
    Serial.print("\t");
    Serial.print(sht.getHumidity(), 2);
    Serial.println(" %RH");
    Serial.println();   //Leerzeile

    // Zwischenspeichern für den CAN-Bus Sensor3
    float Temp3 = sht.getTemperature();
    float Hum3 = sht.getHumidity();

    //Umwandeln in ein Byte
    byte* Temp3HEX = (byte*)&Temp3;
    byte* Hum3HEX = (byte*)&Hum3;

    // send packet: id is 11 bits, packet can contain up to 8 bytes of data
    //Serial.print("Sending packet ... ");
    CAN.beginPacket(0x7E6);       // Start der CAN-Bus-Nachricht auf Adresse 0x7E6 (Wert in Dezimal=2022)
    CAN.write(Temp3HEX, HEX);     // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.write(Hum3HEX, HEX);      // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.endPacket();              // Ende der CAN-Bus-Nachricht
    //Serial.println("done");

    // Statusleuchte 13 AUS
    digitalWrite(13, LOW);

    //Datenübertragung des I²C-Bus auf Kanal 3 (Adresse 2) beenden
    MP.disableChannel(2);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));   
  }
  // Wenn Sensor3 nicht angeschlossen ist
  else {
    //Ausgabe über den seriellen Monitor
    Serial.println("kein Sensor3 angeschlossen");

    // Den Speicher des CAN-Bus für Sensor3 auf null setzten
    CAN.beginPacket(0x7E6);   // Start der CAN-Bus-Nachricht auf Adresse 0x7E6E (Wert in Dezimal=2022)
    CAN.write(0x00);          // Byte0 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte1 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte2 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte3 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte4 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte5 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte6 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte7 zurücksetzen (Wert in Dezimal=0)
    CAN.endPacket();          // Ende der CAN-Bus-Nachricht 

    //Datenübertragung des I²C-Bus auf Kanal 3 (Adresse 2) beenden
    MP.disableChannel(2);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));
  }
//-----------------------------------------------------------------------------------------------------------------------
      // Sensor4:
  // starten des I²C-Multiplexer auf Sensor4=Adresse3
  MP.enableChannel(3);
  MP.selectChannel(3);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));

  // Ausgabe über den seriellen Monitor
  Serial.print("Luftfeuchtigkeitssensor 4\n");

  //Heizung einschalten
  int getError(); //eventuelle Fehler des SHT85 zurücksetzen
  if (digitalRead(HeizungsSchalter) == 1) 
    sht.heatOn();
  else
    sht.heatOff();
        //delay(1);//Reaktionszeit abwarten

  // Abfrage Heizung Sensor4
  if (sht.isHeaterOn() == 1)
    Serial.print("Heizung Sensor 4 An \n");

  // auslesen von Sensor4
  sht.read(Messgeschwindigkeit);         // default = true/fast       slow = false

  // Wenn Sensor4 angeschlossen ist
  if (sht.read() == true) {

    // Statusleuchte 13 AN
    digitalWrite(13, HIGH);

    // serieller Monitor Sensor4
    Serial.print("\t");
    Serial.print(sht.getTemperature(), 2);
    Serial.print(" °C");
    Serial.print("\t");
    Serial.print(sht.getHumidity(), 2);
    Serial.println(" %RH");
    Serial.println();   //Leerzeile

    // Zwischenspeichern für den CAN-Bus Sensor4
    float Temp4 = sht.getTemperature();
    float Hum4 = sht.getHumidity();

    //Umwandeln in ein Byte
    byte* Temp4HEX = (byte*)&Temp4;
    byte* Hum4HEX = (byte*)&Hum4;

    // send packet: id is 11 bits, packet can contain up to 8 bytes of data
    //Serial.print("Sending packet ... ");
    CAN.beginPacket(0x7E7);       // Start der CAN-Bus-Nachricht auf Adresse 0x7E7 (Wert in Dezimal=2023)
    CAN.write(Temp4HEX, HEX);     // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.write(Hum4HEX, HEX);      // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.endPacket();              // Ende der CAN-Bus-Nachricht
    //Serial.println("done");

    // Statusleuchte 13 AUS
    digitalWrite(13, LOW);

    //Datenübertragung des I²C-Bus auf Kanal 4 (Adresse 3) beenden
    MP.disableChannel(3);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));   
  }
  // Wenn Sensor4 nicht angeschlossen ist
  else {
    //Ausgabe über den seriellen Monitor
    Serial.println("kein Sensor4 angeschlossen");

    // Den Speicher des CAN-Bus für Sensor4 auf null setzten
    CAN.beginPacket(0x7E7);   // Start der CAN-Bus-Nachricht auf Adresse 0x7E7 (Wert in Dezimal=2023)
    CAN.write(0x00);          // Byte0 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte1 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte2 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte3 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte4 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte5 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte6 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte7 zurücksetzen (Wert in Dezimal=0)
    CAN.endPacket();          // Ende der CAN-Bus-Nachricht 

    //Datenübertragung des I²C-Bus auf Kanal 4 (Adresse 3) beenden
    MP.disableChannel(3);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));
  }
//-----------------------------------------------------------------------------------------------------------------------
        // Sensor5:
  // starten des I²C-Multiplexer auf Sensor5=Adresse4
  MP.enableChannel(4);
  MP.selectChannel(4);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));

  // Ausgabe über den seriellen Monitor
  Serial.print("Luftfeuchtigkeitssensor 5\n");

  //Heizung einschalten
  int getError(); //eventuelle Fehler des SHT85 zurücksetzen
  if (digitalRead(HeizungsSchalter) == 1) 
    sht.heatOn();
  else
    sht.heatOff();
        //delay(1);//Reaktionszeit abwarten

  // Abfrage Heizung Sensor5
  if (sht.isHeaterOn() == 1)
    Serial.print("Heizung Sensor 5 An \n");

  // auslesen von Sensor5
  sht.read(Messgeschwindigkeit);         // default = true/fast       slow = false

  // Wenn Sensor4 angeschlossen ist
  if (sht.read() == true) {

    // Statusleuchte 13 AN
    digitalWrite(13, HIGH);

    // serieller Monitor Sensor5
    Serial.print("\t");
    Serial.print(sht.getTemperature(), 2);
    Serial.print(" °C");
    Serial.print("\t");
    Serial.print(sht.getHumidity(), 2);
    Serial.println(" %RH");
    Serial.println();   //Leerzeile

    // Zwischenspeichern für den CAN-Bus Sensor5
    float Temp5 = sht.getTemperature();
    float Hum5 = sht.getHumidity();

    //Umwandeln in ein Byte
    byte* Temp5HEX = (byte*)&Temp5;
    byte* Hum5HEX = (byte*)&Hum5;

    // send packet: id is 11 bits, packet can contain up to 8 bytes of data
    //Serial.print("Sending packet ... ");
    CAN.beginPacket(0x7E8);       // Start der CAN-Bus-Nachricht auf Adresse 0x7E8 (Wert in Dezimal=2024)
    CAN.write(Temp5HEX, HEX);     // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.write(Hum5HEX, HEX);      // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.endPacket();              // Ende der CAN-Bus-Nachricht
    //Serial.println("done");

    // Statusleuchte 13 AUS
    digitalWrite(13, LOW);

    //Datenübertragung des I²C-Bus auf Kanal 5 (Adresse 4) beenden
    MP.disableChannel(4);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));   
  }
  // Wenn Sensor5 nicht angeschlossen ist
  else {
    //Ausgabe über den seriellen Monitor
    Serial.println("kein Sensor5 angeschlossen");

    // Den Speicher des CAN-Bus für Sensor5 auf null setzten
    CAN.beginPacket(0x7E8);   // Start der CAN-Bus-Nachricht auf Adresse 0x7E8 (Wert in Dezimal=2024)
    CAN.write(0x00);          // Byte0 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte1 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte2 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte3 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte4 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte5 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte6 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte7 zurücksetzen (Wert in Dezimal=0)
    CAN.endPacket();          // Ende der CAN-Bus-Nachricht 

    //Datenübertragung des I²C-Bus auf Kanal 5 (Adresse 4) beenden
    MP.disableChannel(4);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));
  }
//-----------------------------------------------------------------------------------------------------------------------
        // Sensor6:
  // starten des I²C-Multiplexer auf Sensor6=Adresse5
  MP.enableChannel(5);
  MP.selectChannel(5);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));

  // Ausgabe über den seriellen Monitor
  Serial.print("Luftfeuchtigkeitssensor 6\n");

  //Heizung einschalten
  int getError(); //eventuelle Fehler des SHT85 zurücksetzen
  if (digitalRead(HeizungsSchalter) == 1) 
    sht.heatOn();
  else
    sht.heatOff();
        //delay(1);//Reaktionszeit abwarten

  // Abfrage Heizung Sensor6
  if (sht.isHeaterOn() == 1)
    Serial.print("Heizung Sensor 6 An \n");

  // auslesen von Sensor6
  sht.read(Messgeschwindigkeit);         // default = true/fast       slow = false

  // Wenn Sensor6 angeschlossen ist
  if (sht.read() == true) {

    // Statusleuchte 13 AN
    digitalWrite(13, HIGH);

    // serieller Monitor Sensor6
    Serial.print("\t");
    Serial.print(sht.getTemperature(), 2);
    Serial.print(" °C");
    Serial.print("\t");
    Serial.print(sht.getHumidity(), 2);
    Serial.println(" %RH");
    Serial.println();   //Leerzeile

    // Zwischenspeichern für den CAN-Bus Sensor6
    float Temp6 = sht.getTemperature();
    float Hum6 = sht.getHumidity();

    //Umwandeln in ein Byte
    byte* Temp6HEX = (byte*)&Temp6;
    byte* Hum6HEX = (byte*)&Hum6;

    // send packet: id is 11 bits, packet can contain up to 8 bytes of data
    //Serial.print("Sending packet ... ");
    CAN.beginPacket(0x7E9);       // Start der CAN-Bus-Nachricht auf Adresse 0x7E9 (Wert in Dezimal=2025)
    CAN.write(Temp6HEX, HEX);     // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.write(Hum6HEX, HEX);      // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.endPacket();              // Ende der CAN-Bus-Nachricht
    //Serial.println("done");

    // Statusleuchte 13 AUS
    digitalWrite(13, LOW);

    //Datenübertragung des I²C-Bus auf Kanal 6 (Adresse 5) beenden
    MP.disableChannel(5);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));   
  }
  // Wenn Sensor6 nicht angeschlossen ist
  else {
    //Ausgabe über den seriellen Monitor
    Serial.println("kein Sensor6 angeschlossen");

    // Den Speicher des CAN-Bus für Sensor6 auf null setzten
    CAN.beginPacket(0x7E9);   // Start der CAN-Bus-Nachricht auf Adresse 0x7E9 (Wert in Dezimal=2025)
    CAN.write(0x00);          // Byte0 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte1 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte2 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte3 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte4 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte5 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte6 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte7 zurücksetzen (Wert in Dezimal=0)
    CAN.endPacket();          // Ende der CAN-Bus-Nachricht 

    //Datenübertragung des I²C-Bus auf Kanal 6 (Adresse 5) beenden
    MP.disableChannel(5);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));
  }
//-----------------------------------------------------------------------------------------------------------------------
        // Sensor7:
  // starten des I²C-Multiplexer auf Sensor7=Adresse6
  MP.enableChannel(6);
  MP.selectChannel(6);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));

  // Ausgabe über den seriellen Monitor
  Serial.print("Luftfeuchtigkeitssensor 7\n");

  //Heizung einschalten
  int getError(); //eventuelle Fehler des SHT85 zurücksetzen
  if (digitalRead(HeizungsSchalter) == 1) 
    sht.heatOn();
  else
    sht.heatOff();
        //delay(1);//Reaktionszeit abwarten

  // Abfrage Heizung Sensor7
  if (sht.isHeaterOn() == 1)
    Serial.print("Heizung Sensor 7 An \n");

  // auslesen von Sensor7
  sht.read(Messgeschwindigkeit);         // default = true/fast       slow = false

  // Wenn Sensor7 angeschlossen ist
  if (sht.read() == true) {

     // Statusleuchte 13 AN
    digitalWrite(13, HIGH);

    // serieller Monitor Sensor7
    Serial.print("\t");
    Serial.print(sht.getTemperature(), 2);
    Serial.print(" °C");
    Serial.print("\t");
    Serial.print(sht.getHumidity(), 2);
    Serial.println(" %RH");
    Serial.println();   //Leerzeile

    // Zwischenspeichern für den CAN-Bus Sensor7
    float Temp7 = sht.getTemperature();
    float Hum7 = sht.getHumidity();

    //Umwandeln in ein Byte
    byte* Temp7HEX = (byte*)&Temp7;
    byte* Hum7HEX = (byte*)&Hum7;

    // send packet: id is 11 bits, packet can contain up to 8 bytes of data
    //Serial.print("Sending packet ... ");
    CAN.beginPacket(0x7EA);       // Start der CAN-Bus-Nachricht auf Adresse 0x7EA (Wert in Dezimal=2026)
    CAN.write(Temp7HEX, HEX);     // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.write(Hum7HEX, HEX);      // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.endPacket();              // Ende der CAN-Bus-Nachricht
    //Serial.println("done");

    // Statusleuchte 13 AUS
    digitalWrite(13, LOW);

    //Datenübertragung des I²C-Bus auf Kanal 7 (Adresse 6) beenden
    MP.disableChannel(6);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));   
  }
  // Wenn Sensor7 nicht angeschlossen ist
  else {
    //Ausgabe über den seriellen Monitor
    Serial.println("kein Sensor7 angeschlossen");

    // Den Speicher des CAN-Bus für Sensor7 auf null setzten
    CAN.beginPacket(0x7EA);   // Start der CAN-Bus-Nachricht auf Adresse 0x7EA (Wert in Dezimal=2026)
    CAN.write(0x00);          // Byte0 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte1 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte2 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte3 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte4 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte5 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte6 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte7 zurücksetzen (Wert in Dezimal=0)
    CAN.endPacket();          // Ende der CAN-Bus-Nachricht 

    //Datenübertragung des I²C-Bus auf Kanal 7 (Adresse 6) beenden
    MP.disableChannel(6);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));
  }
//-----------------------------------------------------------------------------------------------------------------------
        // Sensor8:
  // starten des I²C-Multiplexer auf Sensor8=Adresse7
  MP.enableChannel(7);
  MP.selectChannel(7);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));

  // Ausgabe über den seriellen Monitor
  Serial.print("Luftfeuchtigkeitssensor 8\n");

  //Heizung einschalten
  int getError(); //eventuelle Fehler des SHT85 zurücksetzen
  if (digitalRead(HeizungsSchalter) == 1) 
    sht.heatOn();
  else
    sht.heatOff();
        //delay(1);//Reaktionszeit abwarten

  // Abfrage Heizung Sensor8
  if (sht.isHeaterOn() == 1)
    Serial.print("Heizung Sensor 8 An \n");

  // auslesen von Sensor8
  sht.read(Messgeschwindigkeit);         // default = true/fast       slow = false

  // Wenn Sensor8 angeschlossen ist
  if (sht.read() == true) {

    // Statusleuchte 13 AN
    digitalWrite(13, HIGH);

    // serieller Monitor Sensor8
    Serial.print("\t");
    Serial.print(sht.getTemperature(), 2);
    Serial.print(" °C");
    Serial.print("\t");
    Serial.print(sht.getHumidity(), 2);
    Serial.println(" %RH");
    Serial.println();   //Leerzeile

    // Zwischenspeichern für den CAN-Bus Sensor8
    float Temp8 = sht.getTemperature();
    float Hum8 = sht.getHumidity();

    //Umwandeln in ein Byte
    byte* Temp8HEX = (byte*)&Temp8;
    byte* Hum8HEX = (byte*)&Hum8;

    // send packet: id is 11 bits, packet can contain up to 8 bytes of data
    //Serial.print("Sending packet ... ");
    CAN.beginPacket(0x7EB);       // Start der CAN-Bus-Nachricht auf Adresse 0x7EB (Wert in Dezimal=2027)
    CAN.write(Temp8HEX, HEX);     // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.write(Hum8HEX, HEX);      // Da hier ein float Datentyp übertragen wird, werden 4Byte der CAN-Bus-Nachricht gefüllt
    CAN.endPacket();              // Ende der CAN-Bus-Nachricht
    //Serial.println("done");

    // Statusleuchte 13 AUS
    digitalWrite(13, LOW);

    //Datenübertragung des I²C-Bus auf Kanal 8 (Adresse 7) beenden
    MP.disableChannel(7);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));   
  }
  // Wenn Sensor8 nicht angeschlossen ist
  else {
    //Ausgabe über den seriellen Monitor
    Serial.println("kein Sensor8 angeschlossen");

    // Den Speicher des CAN-Bus für Sensor8 auf null setzten
    CAN.beginPacket(0x7EB);   // Start der CAN-Bus-Nachricht auf Adresse 0x7EB (Wert in Dezimal=2027)
    CAN.write(0x00);          // Byte0 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte1 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte2 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte3 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte4 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte5 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte6 zurücksetzen (Wert in Dezimal=0)
    CAN.write(0x00);          // Byte7 zurücksetzen (Wert in Dezimal=0)
    CAN.endPacket();          // Ende der CAN-Bus-Nachricht 

    //Datenübertragung des I²C-Bus auf Kanal 8 (Adresse 7) beenden
    MP.disableChannel(7);
      //Serial.print("MP-Kanal 1:");
      //Serial.println(MP.isEnabled(0));
      //Serial.print("MP-Kanal 2:");
      //Serial.println(MP.isEnabled(1));
  }
//-----------------------------------------------------------------------------------------------------------------------

  // Stoppuhr Ende
  elapsedMillis = millis() - previousMillis;

  // Ausgabe der Durchgangsdauer über den seriellen Monitor
  Serial.print("Durchgangsdauer:  ");
  Serial.print(elapsedMillis);
  Serial.println(" Millisekunden");
  Serial.println();   //Leerzeile
  Serial.println();   //Leerzeile
  Serial.println();   //Leerzeile
//-----------------------------------------------------------------------------------------------------------------------  
}
//!ENDE!
RobTillaart commented 9 months ago

Thanks for your question, I will first add proper code tags

RobTillaart commented 9 months ago

@BenjaminBernhardt

Just to be sure, are you asking me to analyze 929 lines of code?

A quick look shows you are using one SHT85 object to read out multiple. Think you should start with creating an SHT85 object per sensor. Then you can monitor and manipulate the heat-up time per sensor

For more support, please provide a minimal example that shows the problem.

BenjaminBernhardt commented 9 months ago

Hello Rob,

Thanks for the answer. I dont know how to create an object, but i will find the answer tomorrow If im Back at Work......Maybe this will solf the Problem. Everything else runs perfekt. I can read the different Sensors over canbus via a datalogger.

After Sensor 1 the Lines are all the same. Im stucking at this Point:

//Abfrage des HeizungsSchalter SchalterStatus=digitalRead(HeizungsSchalter); Serial.println(SchalterStatus); Serial.println(sht.getError());

//Heizung einschalten int getError(); //eventuelle Fehler des SHT85 zurücksetzen if (digitalRead(HeizungsSchalter) == 1) sht.heatOn(); else sht.heatOff(); //delay(1);//Reaktionszeit abwarten

Im so sorry. Im an Electronic technicant but a Bit of a newbee at the c++ language.

Thx.

RobTillaart commented 9 months ago

@BenjaminBernhardt

YOu have 

SHT85 sht;

which must become

SHT85 sht_1;
SHT85 sht_2;
SHT85 sht_3;
etc

and you must keep the sensor ID in line with the channel of the multiplexer.

BenjaminBernhardt commented 9 months ago

Thats it! Great. Many thanks. :)

Have a good, peaceful Christmas time.

Greetings from Cologne

RobTillaart commented 9 months ago

If that solves the issue you may close it.

BenjaminBernhardt commented 9 months ago

Thx

RobTillaart commented 9 months ago

Have a good, peaceful Christmas time.

Same for you, as they say in South Africa, may your dreams get wings!

Regards from Gemert,