HM-LevelSensor: Ultraschall-Füllstandsmessung für HomeMatic

User stellen ihre Haussteuerung vor

Moderator: Co-Administratoren

DJDieter
Beiträge: 311
Registriert: 11.01.2008, 14:41
System: Alternative CCU (auf Basis OCCU)
Hat sich bedankt: 33 Mal
Danksagung erhalten: 19 Mal

Re: HM-LevelSensor: Ultraschall-Füllstandsmessung für HomeMa

Beitrag von DJDieter » 02.05.2018, 21:05

Hallo Mathias,

vielen Dank für deine Antwort :D .
In der loop-Funktion (Zeile 312) den Code einfügen, um den Sensor auszulesen.
Das krieg ich problemlos hin.
Und die mapToDistance-Funktion (Zeile 221) für die Einbeziehung der Temperatur erweitern.
Da beißt es bei mir dann leider aus. Kannst du mir bitte hier vielleicht etwas detailierter helfen?


Schon mal vielen Dank und viele Grüße
Dieter
Raspberry PI 4 mit RaspberryMatic, 4 LAN-Gateways, zwei HmIP-HAP und 248 Geräte
CUxD mit 357 Kanälen auf 64 Geräten
Zusatzsoftware: XML-API, CUxD-Highcharts, NEO-Server, Programmedrucken, CUxD, E-Mail, Philips Hue, Messenger, CCU-Historian, JB-HP-Devices, HomeKit HomeMatic
Anbindungen: Wolf eBus; NodeMCU-Ultraschall-Füllstandsmessung mit Temperatureinfluß; Fußbodenheizung mit Rücklauftemperaturbegrenzer (RTL)

Mac-Oshi
Beiträge: 2
Registriert: 28.08.2018, 22:02

Re: HM-LevelSensor: Ultraschall-Füllstandsmessung für HomeMatic

Beitrag von Mac-Oshi » 28.08.2018, 22:05

Hallo Mathias,

das würde mich auch sehr interessieren. Ich benutze einen LM35 Temperatursensor.

Gruß Alex

DJDieter
Beiträge: 311
Registriert: 11.01.2008, 14:41
System: Alternative CCU (auf Basis OCCU)
Hat sich bedankt: 33 Mal
Danksagung erhalten: 19 Mal

Re: HM-LevelSensor: Ultraschall-Füllstandsmessung für HomeMatic

Beitrag von DJDieter » 28.08.2018, 22:38

Hier mal mein zurechtgebastelter Arduino-Sketch. Bei mir läuft er. Ob richtig oder nicht kann ich (noch) nicht mit abschließender Sicherheit sagen. Bis jetzt sieht's gut aus. Beim Verwenden des Codes bitte beachten, dass ich auch diverse andere Änderungen gemacht habe.

Code: Alles auswählen

// *** KONFIGURATION ***

// Luftfeuchtigkeit im Tank [%] (the effect is very low)
  const auto AIR_HUMIDITY = 50.0;

// Korrekturfaktor je nach Ultraschallmodul (alt: 1.0353)
  const auto KORREKTURFAKTOR = 0.985;

// Pins des Ultraschallsensor-Moduls
  const auto TRIGGER_PIN = A0;
  const auto ECHO_PIN = A1;

// PIN des Temperatursensors
  const int TMP36 = A2;

  float voltage, TEMPERATUR, TEMPERATUR1, TEMPERATUR2, TEMPERATUR3, TEMPERATUR4, TEMPERATUR5, TEMPERATUR6, TEMPERATUR7, TEMPERATUR8, TEMPERATUR9;

// Pause zwischen den Messungen [s]
  const uint32_t MEASUREMENT_PAUSE = 600;

// start of range [m]
// Abstand vom Boden des Tanks bis zum Sensor [m]. (maximum supported: 5.5m)
  const auto DISTANCE_RANGE_BEGIN = 1.60 + 0.045;
// end of range [m]
// Abstand der Wasseroberfläche des voll gefüllten Tanks bis zum Sensor [m]. Es ist der Mindestabstand des eingesetzten Ultraschallmoduls (0.25) zu beachten.(maximum supported: 5.5m, a value below DISTANCE_RANGE_BEGIN is allowed)
  const auto DISTANCE_RANGE_END = 0.045;
// good quality distance [m]
// (max. distance from median, only good values are included in the final result)
  const auto DISTANCE_GOOD_QUALITY = 0.02;
// the offset is added to the measured value [m]
// (the value depends on the used ultra sonic module, e.g. 0.017m for JSN-SR04T)
  const auto DISTANCE_OFFSET = 0;

// number of additional echoes to skip
  const auto NUM_SKIP_ECHOES = 5;
// number of samples
  const auto NUM_SAMPLES = 10;
// mininum number of good samples;
  const auto NUM_GOOD_SAMPLES = 4;

// enable debug messages over serial port
  const auto DEBUG_ENABLE = true;
// baud rate for monitoring [bits/s]
//  const auto BAUD_RATE = 9600;
  const auto BAUD_RATE = 9600;
// *** CONSTANTS ***

// output start of range
  const uint8_t OUT_RANGE_MIN = 0;
// output end of range
// (OUT_RANGE_MAX must be greater than OUT_RANGE_MIN)
  const uint8_t OUT_RANGE_MAX = 254;
// invalid measurement value
  const uint8_t OUT_INVALID_MEASUREMENT = 255;

  const uint16_t INVALID_MEASUREMENT = 0;

// *** GLOBAL VARIABLES ***

// measured samples
  uint16_t samples[NUM_SAMPLES];
// points behind the last valid sample
// (if samplesEnd == samples, the array is empty)
  uint16_t *samplesEnd;

// *** FUNCIONS ***

// make one ping
// returns:
//   INVALID:   measurement error
//   otherwise: travelling time [µs/2]
  uint16_t ping()
{
  if (digitalRead(ECHO_PIN)) return INVALID_MEASUREMENT;
// send trigger pulse
  digitalWrite(TRIGGER_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER_PIN, LOW);
  if (digitalRead(ECHO_PIN)) return INVALID_MEASUREMENT;
// higher precision, if interrupts are switched off (this is not allowed on devices with a watchdog active, e.g. Wemos D1)
  noInterrupts();
// measure pulse length
  auto t = pulseIn(ECHO_PIN, HIGH, (max((DISTANCE_RANGE_BEGIN * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0), (DISTANCE_RANGE_END * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0)))) * 2;
  interrupts();
  if (t == 0) return INVALID_MEASUREMENT;
  t += (DISTANCE_OFFSET * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0);
  return t;
}

// prints a comma separated list of the samples
  void printSamples()
{
    for (auto it = samples; it < samplesEnd; )
    {
      Serial.print(*it++);
      if (it < samplesEnd) Serial.print(F(","));
    }
  Serial.println();
}

// fills the samples array
  void rawMeasure()
{
    samplesEnd = samples;
    for (int cnt = 0; cnt < NUM_SAMPLES; ++cnt)
    {
// pause between pings to skip echoes
    if (cnt > 0) delay(((uint32_t(NUM_SKIP_ECHOES) * (max((DISTANCE_RANGE_BEGIN * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0), (DISTANCE_RANGE_END * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0))) / 2 + 999) / 1000));
    auto t = ping();
// store only valid samples
    if (t != INVALID_MEASUREMENT) *samplesEnd++ = t;
    }
}

// remove samples out of range
  void removeOutOfRange()
{
// filter array entries
  auto dstIt = samples;
  for (auto srcIt = samples; srcIt < samplesEnd; ++srcIt)
    if (*srcIt >= (min((DISTANCE_RANGE_BEGIN * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0), (DISTANCE_RANGE_END * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0))) && *srcIt <= (max((DISTANCE_RANGE_BEGIN * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0), (DISTANCE_RANGE_END * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0)))) *dstIt++=*srcIt;
  samplesEnd = dstIt;
}

// needed for sorting via qsort()
  int compare_uint16(const void *a_ptr, const void *b_ptr)
{
    auto a = *(uint16_t *)a_ptr, b = *(uint16_t *)b_ptr;
    return a > b ? 1 : (a < b ? -1 : 0);
}

// calculates the median
  uint16_t median()
{
    auto size = samplesEnd - samples;
    if (size)
    {
// sort
    qsort(samples, size, sizeof(uint16_t), compare_uint16);
    auto mid = samples + size / 2;
// for odd array lengths return the center element 
    if (size & 1) return *mid;
// for even array lengths return the average of the two center elements
    else return (uint32_t(*mid) + uint32_t(*(mid-1))) / 2;
    } else return 0;
}

// remove spikes
  void removeSpikes(uint16_t median)
{
    auto lowerLimit = median - (DISTANCE_GOOD_QUALITY * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0);
    auto upperLimit = median + (DISTANCE_GOOD_QUALITY * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0);
// filter array entries
  auto dstIt = samples;
  for (auto srcIt = samples; srcIt < samplesEnd; ++srcIt)
    if (*srcIt >= lowerLimit && *srcIt <= upperLimit) *dstIt++=*srcIt;
  samplesEnd = dstIt;
}

// calculates the average
  uint16_t average()
{
    auto size = samplesEnd - samples;
   if (size)
  {
      uint32_t sum = 0;
      for (auto it = samples; it < samplesEnd; it++) sum += *it;
      return sum / uint32_t(size);
  }   else return 0;
}

// maps the measured time to the output range
// in: measured time [µs/2]
  uint8_t mapToOutRange(uint16_t in)
  {
// map with rounding to nearest
  in += (int32_t((DISTANCE_RANGE_END * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0)) - (DISTANCE_RANGE_BEGIN * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0)) / (OUT_RANGE_MAX - OUT_RANGE_MIN) / 2;
  return map(in, (DISTANCE_RANGE_BEGIN * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0), (DISTANCE_RANGE_END * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0), OUT_RANGE_MIN, OUT_RANGE_MAX);
  }

// maps the measured time to distance
// in: measured time [µs/2]
// returns: distance [mm]
  uint16_t mapToDistance(uint16_t in)
  {
//    return map(in, TIME_RANGE_BEGIN, TIME_RANGE_END, DISTANCE_RANGE_BEGIN * 1000, DISTANCE_RANGE_END * 1000);
return map(in, DISTANCE_RANGE_BEGIN * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0, DISTANCE_RANGE_END * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0, DISTANCE_RANGE_BEGIN * 1000, DISTANCE_RANGE_END * 1000);
  }

uint8_t measure()
{
// fill the samples array
  rawMeasure();
  if (DEBUG_ENABLE)
  {
    Serial.print(F("MEASURED[µs/2]: ")); printSamples();
  }

// remove out of range samples
  removeOutOfRange();
  if (DEBUG_ENABLE)
  {
    Serial.print(F("IN RANGE[µs/2]: ")); printSamples();
  }
  
// median
  auto med = median();
  if (DEBUG_ENABLE)
  {
    Serial.print(F("SORTED  [µs/2]: ")); printSamples();
    Serial.print(F("MEDIAN  [µs/2]: ")); Serial.println(med);
  }

// remove spikes
  removeSpikes(med);
  if (DEBUG_ENABLE)
  {
    Serial.print(F("CLEANED [µs/2]: ")); printSamples();
  }

// average
  auto avg = average();
  if (DEBUG_ENABLE)
  {
    Serial.print(F("AVERAGE [µs/2]: ")); Serial.println(avg);
  }

// map to output range
  uint16_t distance; // [mm]
  uint8_t out;
// minimum required samples?
  if (samplesEnd - samples >= NUM_GOOD_SAMPLES)
  {
    distance = mapToDistance(avg);
    out = mapToOutRange(avg);
  } else {
    distance = 0;
    out = OUT_INVALID_MEASUREMENT;
  }
  if (DEBUG_ENABLE)
  {
    Serial.print(F("DISTANCE  [mm]: ")); Serial.println(distance);
    Serial.print(F("OUT           : ")); Serial.println(out);
    Serial.print(F("TEMPERATUR    : ")); Serial.println(TEMPERATUR);
    Serial.print(F("SPANNUNG      : ")); Serial.println(voltage);
  }
  return out;
}

void send(uint8_t meas)
{
  PORTB = (PORTB & 0b11100000) | (meas & 0b00011111);
  PORTD = (PORTD & 0b00011111) | (meas & 0b11100000);
}

void blinkLed()
{
  for (int idx = 0; idx < 3; ++idx)
  {
    digitalWrite(LED_BUILTIN, LOW); delay(100);
    digitalWrite(LED_BUILTIN, HIGH); delay(100);
  }
  digitalWrite(LED_BUILTIN, LOW);
}

void setup()
{
  pinMode(LED_BUILTIN, OUTPUT);

// ultra sonic module
  pinMode(TRIGGER_PIN, OUTPUT);
  digitalWrite(TRIGGER_PIN, LOW);
  pinMode(ECHO_PIN, INPUT);

  
  if (DEBUG_ENABLE)
  {
    Serial.begin(BAUD_RATE);
    Serial.println(F("*** ULTRA SONIC LEVEL SENSOR ***"));
    Serial.print(F("DISTANCE_RANGE_BEGIN[mm]: ")); Serial.println(uint16_t(DISTANCE_RANGE_BEGIN * 1000));
    Serial.print(F("DISTANCE_RANGE_END  [mm]: ")); Serial.println(uint16_t(DISTANCE_RANGE_END * 1000));
    Serial.print(F("TIME_RANGE_BEGIN  [µs/2]: ")); Serial.println((DISTANCE_RANGE_BEGIN * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0));
    Serial.print(F("TIME_RANGE_END    [µs/2]: ")); Serial.println((DISTANCE_RANGE_END * 2.0 / (331.3 * KORREKTURFAKTOR + 0.6 * TEMPERATUR + 1.5 * AIR_HUMIDITY / 100.0) * 1000000.0 * 2.0));
  }
}
float getVoltage(int pin)
{
  return (analogRead(pin) * 0.004882814*1.08);
}
void loop()
{
//Tanktemperatur auslesen
  voltage = getVoltage(TMP36);
  TEMPERATUR1 = (voltage - 0.5) * 100.0;
  delay(200);
  voltage = getVoltage(TMP36);
  TEMPERATUR2 = (voltage - 0.5) * 100.0;
  delay(200);
  voltage = getVoltage(TMP36);
  TEMPERATUR3 = (voltage - 0.5) * 100.0;
  delay(200);
  voltage = getVoltage(TMP36);
  TEMPERATUR4 = (voltage - 0.5) * 100.0;
  delay(200);
  voltage = getVoltage(TMP36);
  TEMPERATUR5 = (voltage - 0.5) * 100.0;
  delay(200);
  voltage = getVoltage(TMP36);
  TEMPERATUR6 = (voltage - 0.5) * 100.0;
  delay(200);
  voltage = getVoltage(TMP36);
  TEMPERATUR7 = (voltage - 0.5) * 100.0;
  delay(200);
  voltage = getVoltage(TMP36);
  TEMPERATUR8 = (voltage - 0.5) * 100.0;
  delay(200);
  voltage = getVoltage(TMP36);
  TEMPERATUR9 = (voltage - 0.5) * 100.0;

  TEMPERATUR = (TEMPERATUR1+TEMPERATUR2+TEMPERATUR3+TEMPERATUR4+TEMPERATUR5+TEMPERATUR6+TEMPERATUR7+TEMPERATUR8+TEMPERATUR9)/9;
  
  if (DEBUG_ENABLE) Serial.println();

// turn led on
  digitalWrite(LED_BUILTIN, HIGH);

// measure and send
  uint8_t meas = measure();
  send(meas);

// invalid measurement?
  if (meas == OUT_INVALID_MEASUREMENT) blinkLed(); 
  else digitalWrite(LED_BUILTIN, LOW);

// pause for next measurement
  delay(MEASUREMENT_PAUSE * 1000);
}

Raspberry PI 4 mit RaspberryMatic, 4 LAN-Gateways, zwei HmIP-HAP und 248 Geräte
CUxD mit 357 Kanälen auf 64 Geräten
Zusatzsoftware: XML-API, CUxD-Highcharts, NEO-Server, Programmedrucken, CUxD, E-Mail, Philips Hue, Messenger, CCU-Historian, JB-HP-Devices, HomeKit HomeMatic
Anbindungen: Wolf eBus; NodeMCU-Ultraschall-Füllstandsmessung mit Temperatureinfluß; Fußbodenheizung mit Rücklauftemperaturbegrenzer (RTL)

Mac-Oshi
Beiträge: 2
Registriert: 28.08.2018, 22:02

Re: HM-LevelSensor: Ultraschall-Füllstandsmessung für HomeMatic

Beitrag von Mac-Oshi » 29.08.2018, 14:59

Hallo Dieter,

danke für den Sketch. Hab Ihn auf meinen Temperatursensor (LM35DZ) angepasst, läuft bei mir auch :D
Echt super.

jp112sdl
Beiträge: 12085
Registriert: 20.11.2016, 20:01
Hat sich bedankt: 847 Mal
Danksagung erhalten: 2139 Mal
Kontaktdaten:

Re: HM-LevelSensor: Ultraschall-Füllstandsmessung für HomeMatic

Beitrag von jp112sdl » 29.08.2018, 16:35

Bin gerade zufällig über dieses Projekt gestolpert...
Aber es war sehr aufschlussreich bzgl. des Temperatureinflusses auf die Schallgeschwindigkeit!
Ich hatte zwischenzeitlich eine eigene Ultraschall-Füllstandslösung erarbeitet, die den tatsächlichen Füllstand an die CCU übermittelt.
Das werde ich dann bei mir mal mit in der Berechnung berücksichtigen.

Vielen Dank!

Btw.: Ich habe mit dem SR04 keine guten Ergebnisse erzielt. Derzeit setze ich den MaxSonar MB1040 von MaxBotix ein. Der liefert konstant gute Werte.

VG,
Jérôme ☕️

---
Support for my Homebrew-Devices: Download JP-HB-Devices Addon

Blinderengel
Beiträge: 34
Registriert: 07.06.2015, 22:38

Re: HM-LevelSensor: Ultraschall-Füllstandsmessung für HomeMatic

Beitrag von Blinderengel » 08.12.2018, 21:01

Hi, ich bin auf der Suche über dieses Projekt gestolpert, habe mir alle Teile gekauft so aufgebaut.
Das auslesen ohne HM 8 Bit hat schon mal geklappt, jetzt habe ich den HM 8 Bit mit eingebunden.

Jetzt stehe ich auf dem Schlauch.... wie bekomme ich eine kennliene angezeigt und wie weiß ich das was übertragen wird ?

Vielen Dank

Jörg

Mathias
Beiträge: 1767
Registriert: 03.11.2010, 10:25
System: CCU
Wohnort: Aachen
Hat sich bedankt: 58 Mal
Danksagung erhalten: 253 Mal
Kontaktdaten:

Re: HM-LevelSensor: Ultraschall-Füllstandsmessung für HomeMatic

Beitrag von Mathias » 09.12.2018, 10:20

Hast Du auch das nötige Programm und die Systemvariable auf der CCU erstellt?
Anhand der letzten Ausführung des Programms, siehst Du wann ein Messwert übertragen worden ist.
Den Sendeabstand kannst Du auch testweise auf 15 Sekunden reduzieren, damit häufiger übertragen wird.
Für eine Trend-Kurve musst Du den Wert der Systemvariablen aufzeichnen. Dafür kannst Du z.B. die Protokollierung der CCU oder den CCU-Historian verwenden.

Gruß
Mathias

Blinderengel
Beiträge: 34
Registriert: 07.06.2015, 22:38

Re: HM-LevelSensor: Ultraschall-Füllstandsmessung für HomeMatic

Beitrag von Blinderengel » 09.12.2018, 11:46

Ich habe genau wie im Link erst Seite beschrieben die "var" angelegt und auch das Program.

Wenn ich in der CCU jetzt unter Systemvariable schaue sehe ich aber immer 0l, ich sehe wenn ich den Sensor verschiebe das mein Modul blinkt aber es bleibt bei 0 Liter.

mein Script in HM schaut so aus:
----------------------------
! configuration
var rangeBegin=0.0;
var rangeEnd=6000.0;
var precision=0;
var errorValue=-100.0;
var sysVarName="Zisternenfüllstand";

! read device data point and update system variable
var sv=dom.GetObject("BidCos-RF.XXXXXXXX:3.Wert_des_Dateneingangs").Get(sysVarName);
var src=dom.GetObject("$src$");
if (sv && src) {
var val=src.State();
if (val==255) {
sv.State(errorValue);
} else {
val=(((rangeEnd-rangeBegin)*val)/254.0)+rangeBegin;
sv.State(val.Round(precision));
}
}
----------------------------
Benötige ich noch mehr Programme oder nur das eine wie es beschrieben ist ?


update: habe eben noch mal alles resetet und jetzt habe ich Werte ;)

Blinderengel
Beiträge: 34
Registriert: 07.06.2015, 22:38

Re: HM-LevelSensor: Ultraschall-Füllstandsmessung für HomeMatic

Beitrag von Blinderengel » 23.12.2018, 11:51

Hi

ich habe nach einer Lösung gesucht den Füllstand für meinen Öltank auszulesen.

ich habe mir alles so zusammengebaut und den Sensor HC-SR04 mit verbaut ( da ich wenn der Tank voll ist nur ca. 3cm zum sensor habe.
Was super ist mein Tank ist 6000 Liter also könnte ich fast alles so übernehmen.

mein Tank ist 1.47m plus die 0.02m zum Sensor.

jetzt habe ich mein Sensor oben angebracht, jetzt bekomme ich aber falsche Werte.

er zeigt mir aktuell ca. 3600 Liter an ich habe aber nur noch 2400 Liter drin.

ich habe dies an der Badewanne ( da Flüssigkeit ) simuliert

wenn ich die werte übertrage von der Wanne rechnerisch zum Tank kommen diese Werte raus. ( dies passiert auch wenn ich von den 1.47 die cm unten abziehe, diese würden nicht zum Inhalt meines Tanks passen ) Ich habe auch in den Tank geschaut, ich habe keine Zwischenschicht drin, in der Mitte läuft nur das Rohr was das Öl absaugt.

Sensor CM zum Wasser Menge Am Tank von oben nach unten gemessen
13cm 5300 L auch ca 5300 L
87cm 3800 L ca 2200 L
56 4700 L 3700 L

habt ihr eine Idee ?

vielen dank

automation-fan
Beiträge: 20
Registriert: 25.12.2018, 15:36
Danksagung erhalten: 5 Mal

Re: HM-LevelSensor: Ultraschall-Füllstandsmessung für HomeMatic

Beitrag von automation-fan » 26.12.2018, 20:35

Hallo zusammen,

erst mal Danke für die tolle Arbeit! Habe mein letztes Programm vor ca. 20 Jahren geschrieben und wäre ohne diese Vorlagen chancenlos :-(

Ich möchte zwei Zisternen 6000 l + 8000 l mit dieser USM Messung ausstatten. Als Fühler würde ich gern den JSN-SR04T verwenden, da dieser wasserdicht ist und man die Elektronik abgesetzt installieren kann.

Nun mein Frage / Bedenken:

Der JSN-SR04T wird je nach Internet Quelle mit einen Messwinkel von 50 bzw 70 Grad angegeben.

D.h. aber bei einen Zisternendurchmesser von ca. 2,0 m und einer Installationshöhe von ca. 2,8 m (incl 25cm Mindestabstand) trifft der US die Zisternenwand schon bei ca. 2,15m.

Kann der JSN-SR04T dieses verarbeiten oder wir die Messung unbrauchbar da der US von der Zisternenwand reflektiert wird?

Info wäre schön bevor ich mir die ganz HW bestelle.

Gruß
automation-fan
Zisterne 8000 Liter.pdf
(65.56 KiB) 158-mal heruntergeladen

Antworten

Zurück zu „Projektvorstellungen“