ESP32 Wroom mit Honeywell Drucksensor verbinden

[Thomas (watchout166)]

Hallo, also ich bin komplett neu in dem Bereich, ich habe schon einige 
Projekte gemacht mit Arduino und ESP32, aber eigentlich immer fast mit 
Anleitung. Ich bin über jede Hilfe Dankbar und falls noch weitere Infos 
benötigt werden, gebe ich diese auch gern weiter.

Es besteht folgendes Problem, es ist mir bis jetzt nicht wirklich 
gelungen die Werte im Terminal anzuzeigen. Meldung ist meistens, dass 
der DRDY High bleibt, auch Programmierungen diesen zum umgehen änderten 
nichts. Der Sensor wurde schon öfter mit dem Evaluierungstool von 
Honeywell überprüft, dort funktioniert er auch einwandfrei.

Bei dem Aufbau hab ich mich an das Datenblatt im Anhang gehalten. Bei 
dem Sensor handelt es sich um den RSCDRRE400MDSE3. Die Widerstände sind 
1k OHM und Kondensatoren 10uF und 0,1uF, Empfehlung laut Datenblatt. 
Änderungen bei den Widerständen änderte nichts. Anbei noch der Code, 
welcher schon 100mal angepasst wurde, dass ist soweit mal die aktuelle 
Version. Programmiert in VS Code. Bin dankbar über jede Hilfe!!!!!

#include <Arduino.h>
#include <SPI.h>

// 📌 Pin-Konfiguration ESP32
#define PIN_MOSI    23
#define PIN_MISO    19
#define PIN_SCK     18
#define PIN_CS_ADC  5    // Chip Select ADC
#define PIN_CS_EE   17   // Chip Select EEPROM
#define PIN_DRDY    4    // Data Ready, aktiv LOW

// 📌 SPI-Einstellungen
SPISettings sensorSPISettings(100000, MSBFIRST, SPI_MODE1);   // A
SPISettings eepromSPISettings(1000000, MSBFIRST, SPI_MODE0);  // E

// 📌 Variablen für Kalibrierung
uint16_t OUTPUT_MIN;
uint16_t OUTPUT_MAX;
float PRESSURE_MIN;
float PRESSURE_MAX;

// ---------- EEPROM Lese-Funktion ----------
uint8_t readEEPROMByte(uint16_t address) {
  uint8_t value;
  digitalWrite(PIN_CS_EE, LOW);
  SPI.beginTransaction(eepromSPISettings);
  SPI.transfer(0x03); // READ command
  SPI.transfer((address >> 8) & 0xFF); // High-Byte der Adresse
  SPI.transfer(address & 0xFF);        // Low-Byte der Adresse
  value = SPI.transfer(0x00);
  SPI.endTransaction();
  digitalWrite(PIN_CS_EE, HIGH);
  return value;
}

// ---------- Kalibrierwerte laden ----------
void loadCalibrationFromEEPROM() {
  Serial.println("📥 Lade Kalibrierwerte aus EEPROM...");

  OUTPUT_MIN   = (readEEPROMByte(0x1A) << 8) | readEEPROMByte(0x1B
  OUTPUT_MAX   = (readEEPROMByte(0x1C) << 8) | readEEPROMByte(0x1D
  PRESSURE_MIN = (int16_t)((readEEPROMByte(0x20) << 8) | readEEPRO
  PRESSURE_MAX = (int16_t)((readEEPROMByte(0x22) << 8) | readEEPRO

  Serial.printf("⚙️ OUTPUT_MIN: %u\n", OUTPUT_MIN);
  Serial.printf("⚙️ OUTPUT_MAX: %u\n", OUTPUT_MAX);
  Serial.printf("⚙️ PRESSURE_MIN: %.2f mbar\n", PRESSURE_MIN);
  Serial.printf("⚙️ PRESSURE_MAX: %.2f mbar\n", PRESSURE_MAX);
}

// ---------- Sensor-Initialisierung ----------
void initSensor() {
  Serial.println("🔧 Initialisiere ADC-Bereich...");

  digitalWrite(PIN_CS_ADC, LOW);
  SPI.beginTransaction(sensorSPISettings);
  SPI.transfer(0x06); // RESET
  SPI.endTransaction();
  digitalWrite(PIN_CS_ADC, HIGH);
  delay(100);

  digitalWrite(PIN_CS_ADC, LOW);
  SPI.beginTransaction(sensorSPISettings);
  SPI.transfer(0x08); // START
  SPI.endTransaction();
  digitalWrite(PIN_CS_ADC, HIGH);
  delay(50);

  Serial.println("✅ Sensor bereit.");
}

// ---------- DRDY warten ----------
bool waitForDRDY(int timeout_ms = 200) {
  unsigned long start = millis();
  while (digitalRead(PIN_DRDY) == HIGH) {
    if (millis() - start > timeout_ms) {
      Serial.println("⚠️ Timeout bei DRDY – Fallback aktiv.");
      return false;
    }
  }
  return true;
}

// ---------- Setup ----------
void setup() {
  Serial.begin(115200);
  delay(500);

  pinMode(PIN_CS_ADC, OUTPUT);
  pinMode(PIN_CS_EE, OUTPUT);
  pinMode(PIN_DRDY, INPUT_PULLUP);

  digitalWrite(PIN_CS_ADC, HIGH);
  digitalWrite(PIN_CS_EE, HIGH);

  SPI.begin(PIN_SCK, PIN_MISO, PIN_MOSI, -1);

  loadCalibrationFromEEPROM();
  initSensor();
}

// ---------- Hauptloop ----------
void loop() {
  uint8_t data[4] = {0};

  if (!waitForDRDY()) {
    delay(5);
  }

  digitalWrite(PIN_CS_ADC, LOW);
  SPI.beginTransaction(sensorSPISettings);
  SPI.transfer16(0xF000);
  for (int i = 0; i < 4; i++) {
    data[i] = SPI.transfer(0x00);
  }
  SPI.endTransaction();
  digitalWrite(PIN_CS_ADC, HIGH);

  uint8_t status = (data[0] & 0xC0) >> 6;
  if (status != 0) {
    Serial.print("❌ Fehlerstatus: ");
    switch (status) {
      case 1: Serial.println("Ungültiger Befehl"); break;
      case 2: Serial.println("Diagnosefehler"); break;
      case 3: Serial.println("Kritischer Fehler"); break;
    }
    delay(1000);
    return;
  }

  uint16_t rawPressure = ((data[0] & 0x3F) << 8) | data[1];
  float pressure_mbar = ((float)(rawPressure - OUTPUT_MIN) *
                         (PRESSURE_MAX - PRESSURE_MIN)) /
                         (OUTPUT_MAX - OUTPUT_MIN) + PRESSURE_MIN;

  Serial.printf("📊 Rohwert: %u → %.2f mbar\n", rawPressure, press

  delay(1000);
}

[Sebastian R. (sebastian_r569)]

Thomas schrieb:
> Es besteht folgendes Problem, es ist mir bis jetzt nicht wirklich
> gelungen die Werte im Terminal anzuzeigen.

Schritt 1 wäre vielleicht mal, den offensichtlich KI-generierten 
Quelltext von den Emojis zu befreien.

[Rainer W. (rawi)]

Thomas schrieb:
> Es besteht folgendes Problem, es ist mir bis jetzt nicht wirklich
> gelungen die Werte im Terminal anzuzeigen. Meldung ist meistens, dass
> der DRDY High bleibt, auch Programmierungen diesen zum umgehen änderten
> nichts. Der Sensor wurde schon öfter mit dem Evaluierungstool von
> Honeywell überprüft, dort funktioniert er auch einwandfrei.

Dann wäre der nächste Schritt doch, zu analysieren, wo das Problem 
liegt. Erster Schritt ist das Ansprechen des Sensors. Du hast eine 
funktionierende Software vom Entwicklungstool und deine Version. Also 
nimmst du als erstes Oszi und guckst, ob die Signale auf dem Bus 
ordentlich aussehen. Mit einen Logikanalysator kannst dir dann die 
Kommunikation ansehen, insbesondere, was bei deiner Software anders 
läuft. Sobald die Daten richtig von der Schnittstelle kommen, gehst du 
dann die Verarbeitung und die Anzeige von Werten an. Einfach Schritt für 
Schritt vorgehen und nicht einen (für dich zu) großen Sprung tun und 
sich wundern, wenn es nicht sofort funktioniert.

Bist du sicher, dass dein Ausgabegerät mit den Emojis in den 
println()-Aufrufen irgendetwas anfangen kann?

[Obelix X. (obelix)]

Ich muss zu viel scrollen, deswegen schaue ich mir den Quellcode nicht 
an.

--> Netiquette & Forenregeln. (Kann da die KI noch nicht helfen?

[Ben B. (Firma: Funkenflug Industries) (stromkraft)]

Hast Du mal probiert ob es funktioniert wenn sich der Sensor den SPI 
nicht mit dem EEPROM teilen muss? Wieso verwendest Du den EEPROM 
überhaupt und holst Dir die Kalibrationsdaten nicht mittels 
SPIFFS/LittleFS aus dem Flash des ESP?