Berry measurement update frequency based on Teleperiod

[patrmis]

I have a tank that empties very slowly over days or weeks, and then, when triggered by float, fills within minutes.
An ESP32 with serial connected SR04 is monitoring the level.

Because the SR04 is a mechanical device, I have been getting a lot of failures. I want to avoid measuring every second (like the Tasmota built in Trig/Echo method), since I only need measurements every 30min while the tank is emptying. During filling, Tasmota receives a TelePeriod 30 update, and which reverts back to TelePeriod 1800 once the pump switches off. Also, because the SR04 is notoriously inconsistent, I've added some measurement filtering.

Berry Serial SR04 driver:

  var qty
  var duration
  var txReqd
  var rxReqd
  var minLevel
  var maxLevel
  var cur_meas
  var rxDelay

  var ser
  var txTime
  var startTime
  var average
  var percent
  var distances
  var topic
  var tTopic
  var telePeriod
  var success
  var lastMeasure

  def init()
    self.qty = 7
    self.duration = 15000
    self.txReqd = true
    self.rxReqd = true
    self.minLevel = 800
    self.maxLevel = 400
    self.rxDelay = 500
    self.success = false
    self.startMeasure()
    self.telePeriod = tasmota.cmd("teleperiod").item("TelePeriod")*1000
  end

  def web_sensor()
    import string
    var msg = string.format(
              "{s}Level{m}%i%%{e}"..
              "{s}Distance{m}%i mm{e}",
              self.percent,self.average)
    tasmota.web_send_decimal(msg)
  end

  def json_append()
    if tasmota.millis() - self.lastMeasure > self.telePeriod
      self.startMeasure()
    end
    import string
    var msg = string.format(",\"Level\":%i,\"Distance\":%i",
              self.percent, self.average)
    tasmota.response_append(msg)
  end

  def bubble_sort(lst)
    var n = lst.size()
    for i: 0..n-1
      for j: 0..n-i-2
        if lst[j] > lst[j+1]
          var tmp = lst[j]
          lst[j] = lst[j+1]
          lst[j+1] = tmp
        end
      end
    end
    return lst
  end

  def postProcess()
    var sorted = self.bubble_sort(self.distances)
    self.average = (sorted[1]+sorted[2]+sorted[3]+sorted[4]+sorted[5])/5
    self.percent = 100.0*(self.minLevel - self.average)/(self.minLevel - self.maxLevel)
  end

  def rx_ser()
    tasmota.delay(10)
    if tasmota.millis() - self.txTime > self.rxDelay
      if self.ser.available() == 3
        var msg = self.ser.read()
        #print("msg:", msg.tohex())
        self.distances[self.cur_meas] = msg.get(0, -3) / 1000
        self.cur_meas = self.cur_meas + 1
        self.rxReqd = false
        self.txReqd = true
      else
        print("Not 3 bytes received, received bytes = ", self.ser.available())
        self.txReqd = true
      end
    end
  end

  def tx_ser()
    self.txTime = tasmota.millis()
    self.ser.write(bytes().fromhex("A0"))
    self.txReqd = false
    self.rxReqd = true
  end

  def startMeasure()
    self.cur_meas = 0
    self.startTime = tasmota.millis()
    self.success = false
    self.distances = []
    self.distances.resize(self.qty)

    self.ser = serial(27, 26, 9600, serial.SERIAL_8N1)

    while tasmota.millis() - self.startTime < self.duration
      if self.ser
        if self.txReqd
          self.tx_ser()
        end
        if self.rxReqd
          self.rx_ser()
        end
        if self.cur_meas == self.qty
          self.success = true
          self.lastMeasure = self.startTime
          break
        end
      else
        break
      end
    end

    if self.ser
      self.ser.close()
    end
    if self.success
      self.postProcess()
    end
  end
end


SR04 = SR04()
tasmota.add_driver(SR04)

It works fine as long as I don't change the TelePeriod.

However if I put self.telePeriod = tasmota.cmd("teleperiod").item("TelePeriod")*1000 inside json_append() to catch changes, the execution of tasmota.cmd("teleperiod") seems to trigger a TelePublish (i.e. MQT: tele/topic/STATE) every second, which quickly fills my database.

I've considered leaving the code as is and sending a BrRestart along with the TelePeriod update remotely to initiate the change in polling frequency. But I’d much prefer a local Tasmota‑based solution.

Options I've considered without success:

• A rule like ON *TelePeriod Change ?!?!* DO BrRestart ENDON but I can't find the correct trigger
• Having Berry read the TelePeriod without triggering a TelePublish.
• Some other (less hackish) solution I might be unaware of.

Please note: I’m not a programmer, and the code above has taken me days to piece together from the Language Reference, Cookbook, and other Berry sources. I’d appreciate constructive feedback only. I’m also aware that postProcess() is hardcoded to 5/7; making it dynamic with 1..len(sorted)-1 would take me more time to get right.

Any help is greatly appreciated!

[sfromis]

You are right that executing the TelePeriod command, with or without argument, will trigger the telemetry period processing, meaning publishing the usual payload. It will also resynchronize the rhythm to the new starting point.

Thus, just don't issue the command if you simply want to know the value. In your init(), you can instead have a trigger like
tasmota.add_rule('TelePeriod', def (value) self.teleperiod=value end)
And then issue a TelePeriod command to have the boot time value available thereafter.

You should only have to issue the TelePeriod command when you want to change the value. Then the above will update your instance variable.

Don't venture into issuing BrRestart command, you've posted no reasoning why. What you gain by avoiding the standard Tasmota SR04 driver measuring every second is not clear.

I've not tried to dive into your code or how details work, but you should not have your own timing loops for polling, as your methods should always return as quickly as possible. Recommended is instead to have callbacks like every_50ms() (if you add your class as a driver), or use tasmota.add_fast_loop to have a function called about 200 times a second. This one should really avoid doing stuff taking time.

[patrmis]

Awesome! Thank you for your prompt and bang-on help.

The tasmota.add_rule('TelePeriod', def (value) self.telePeriod=int(value) end) is exactly what I needed.

Also, as recommended I've removed the processing from the json_append() into the every_100ms() callback and removed any delays so it will just iterate at the native 100ms and process once the time has elapsed as required.

What you gain by avoiding the standard Tasmota SR04 driver measuring every second is not clear?

I've been getting a life of <6 months out of some SR04 sensor before they start playing up. I'm hoping if it's degradation (rather than environmental), by measuring less frequently to extend the life.
But also I get to do error correction/averaging/outlier removal, which I can't with the native SR04 implementation

My final code, in case someone is interested:

  var qty
  var duration
  var txReqd
  var rxReqd
  var minLevel
  var maxLevel
  var cur_meas
  var rxDelay

  var ser
  var txTime
  var startTime
  var average
  var percent
  var distances
  var topic
  var tTopic
  var telePeriod
  var lastMeasure
  var measuring

  def init()
    self.qty = 7
    self.duration = 15000
    self.minLevel = 800
    self.maxLevel = 400
    self.rxDelay = 500
    self.lastMeasure = -1000000000
#   self.telePeriod = tasmota.cmd("teleperiod").item("TelePeriod")*1000
    tasmota.add_rule('TelePeriod', def (value) self.telePeriod=int(value)*1000 end)
    tasmota.cmd("telePeriod")
    print("Teleperiod = ",self.telePeriod)

  end

  def every_100ms()
    if tasmota.millis() - self.lastMeasure > self.telePeriod
      self.measuring = true
    end

    if self.measuring
      if !self.ser
        self.cur_meas = 0
        self.startTime = tasmota.millis()
        self.txReqd = true
        self.rxReqd = true
        self.distances = []
        self.distances.resize(self.qty)
        self.ser = serial(27, 26, 9600, serial.SERIAL_8N1)
      end

      if self.ser
        if self.txReqd
          self.tx_ser()
        end
        if self.rxReqd
          self.rx_ser()
        end
        if self.cur_meas == self.qty
          self.postProcess()
          self.ser.close()
          self.ser = nil
          self.lastMeasure = self.startTime
          self.measuring = false
        end
      end
    end
  end

  def web_sensor()
    import string
    var msg = string.format(
              "{s}Level{m}%i%%{e}"..
              "{s}Distance{m}%i mm{e}",
              self.percent,self.average)
    tasmota.web_send_decimal(msg)
  end

  def json_append()
    import string
    var msg = string.format(",\"Level\":%i,\"Distance\":%i",
              self.percent, self.average)
    tasmota.response_append(msg)
  end

  def bubble_sort(lst)
    var n = lst.size()
    for i: 0..n-1
      for j: 0..n-i-2
        if lst[j] > lst[j+1]
          var tmp = lst[j]
          lst[j] = lst[j+1]
          lst[j+1] = tmp
        end
      end
    end
    return lst
  end

  def postProcess()
    var sorted = self.bubble_sort(self.distances)
    self.average = (sorted[1]+sorted[2]+sorted[3]+sorted[4]+sorted[5])/5
    self.percent = 100.0*(self.minLevel - self.average)/(self.minLevel - self.maxLevel)
    print("Raw measurements = ",sorted)   ###### Just so I know it ran
  end

  def rx_ser()
#    tasmota.delay(10)
    if tasmota.millis() - self.txTime > self.rxDelay
      if self.ser.available() == 3
        var msg = self.ser.read()
        #print("msg:", msg.tohex())
        self.distances[self.cur_meas] = msg.get(0, -3) / 1000
        self.cur_meas = self.cur_meas + 1
        self.rxReqd = false
        self.txReqd = true
      else
        print("Not 3 bytes received, received bytes = ", self.ser.available())
        self.txReqd = true
      end
    end
  end

  def tx_ser()
    self.txTime = tasmota.millis()
    self.ser.write(bytes().fromhex("A0"))
    self.txReqd = false
    self.rxReqd = true
  end

end


SR04 = SR04()
tasmota.add_driver(SR04)

[sfromis]

As your use case is a tank, that sounds like high humidity, which could be bad for the sensor. A waterproof variant JSN-SR04T exists, no experience with it, but I'd guess it to be less susceptible to humidity.

I've had a SR04 connected for years, just humming along without doing anything useful, but seeing reasonable numbers. Still, I don't consider it "good" hardware, and for practical use I'd likely prefer an optical distance-measuring board like VL53L0X. Of course, high humidity and electronics is still risky, some sort of protection could be relevant. I've used BME280 outdoors (of course protected from rain), but saw a couple corrode within 1-2 years. Not the sensor, but the pins on the board. Now I'm using a weather-enclosed SHT31 instead.

An insignificant detail, I see that you decided to have int(value) when getting the TelePeriod value, this should not be needed as it will already be parsed as a number (integer) due to it not being a string in the JSON.