Bed occupancy sensor, need some software help using TouchCal values

[probonopd]

It is possible to build a pressure sensor that can be used, e.g., to detect whether a bed is occupied by (ab)using touch sensor pins to create a pressure sensitive pad by using two layers of alu foil separated by some foam foil. One alu foil is connected to GND, the other is connected to a touch sensor pins. Using this, I can reliably see whether a bed is occupied by looking at the TouchCal raw values.

Details: https://community.home-assistant.io/t/bed-occupancy-sensor-using-parts-you-have/189490

In Tasmota it is currently possible to use the ESP32 touch sensor pins to toggle power on/off.
However, I would like a slightly different behavior:

As long as the TouchCal raw values are above the threshold set with TouchThres, I need the resulting value to be "ON", and as long as values are below the threshold, the resulting value should be "OFF", or vice versa. To increase reliability, a few readings could be averaged.

Could this be implemented in Tasmota or in Berry?

[sfromis]

If you leave TouchCal running, generating a lot of log output, it would be doable to have Berry code following the log lines, parsing for the current touch value, and take action based on that.
https://tasmota.github.io/docs/Berry/#tasmota_log_reader-class

[probonopd]

This kinda works for me but feels rather high overhead and clumsy.

I think it would be much nicer to have such functionality as a native Tasmota sensor type.

import string
import mqtt

class BedOccupancySensor
  var lr
  var is_occupied
  var last_number
  var threshold
  var initial_number
  var hysteresis
  var debounce_count
  var debounce_threshold
  var consecutive_readings
  var percentage  # New variable for threshold percentage

  def init()
    self.lr = tasmota_log_reader()
    self.is_occupied = false
    self.last_number = 0
    self.threshold = 0
    self.initial_number = 0
    self.hysteresis = 0.01  # 1% hysteresis
    self.debounce_count = 0
    self.debounce_threshold = 2  # Number of consecutive readings required to change state
    self.consecutive_readings = 0
    self.percentage = 0.03  # Default to 3%
    tasmota.cmd("TouchCal 1")
    # Wait for before calibration
    tasmota.delay(500)
    tasmota.delay(500)
    tasmota.delay(500)
  end

  def parse_log_line(line)
    var parts = string.split(line, ',')
    if size(parts) > 3
      var last_part = parts[1]
      self.last_number = number(last_part)
      # print("Last Number:", self.last_number)
      # print("Threshold:", self.threshold)

      if self.initial_number == 0
        self.initial_number = self.last_number
        self.threshold = self.initial_number * (1 + self.percentage)  # Use percentage for threshold calculation
        print("Initial number:", self.initial_number)
        print("Threshold:", self.threshold)
      end

      self.check_occupancy()
    end
  end

  def check_occupancy()
    var lower_threshold = self.threshold * (1 - self.hysteresis)
    var upper_threshold = self.threshold * (1 + self.hysteresis)

    if self.is_occupied
      if self.last_number < lower_threshold
        self.consecutive_readings += 1
      else
        self.consecutive_readings = 0
      end
    else
      if self.last_number > upper_threshold
        self.consecutive_readings += 1
      else
        self.consecutive_readings = 0
      end
    end

    if self.consecutive_readings >= self.debounce_threshold
      self.change_occupancy_state(!self.is_occupied)
      self.consecutive_readings = 0
    end
  end

  def change_occupancy_state(new_state)
    if new_state != self.is_occupied
      self.is_occupied = new_state
      if self.is_occupied
        print("Bed is now occupied")
        mqtt.publish("cmnd/tasmota_FF15F2/Backlog", "I2SPlay attention.mp3")
        tasmota.set_power(0, true)
      else
        print("Bed is now vacant")
        mqtt.publish("cmnd/tasmota_FF15F2/Backlog", "I2SPlay attention.mp3")
        tasmota.set_power(0, false)
      end
    end
  end

  def check_logs()
    var ret = self.lr.get_log(2)
    if ret != nil
      var lines = string.split(ret, '\n')
      for line: lines
        if string.find(line, "PLOT:") != -1
          self.parse_log_line(line)
        end
      end
    end
  end

  def every_50ms()
    self.check_logs()
  end

  def json_append()
    var msg = string.format(",\"BedSensor\":{\"Occupied\":%s,\"Value\":%d, \"Threshold\":%d}",
                            self.is_occupied ? "true" : "false", self.last_number, self.threshold)
    tasmota.response_append(msg)
  end

end

# Create an instance of the BedOccupancySensor with a custom percentage if needed.
bed_sensor = BedOccupancySensor()
print("Bed sensor created")

# Register the driver.
tasmota.add_driver(bed_sensor)
print("Bed sensor driver registered")

[sfromis]

Sure, it is high overhead and all that, but it does answer your question about whether it could be implemented using Berry. And I'd not worry too much about overhead, as long as it is workable.

Obviously, it would "not be impossible" to expand the driver handling Button_tc pins with more features, for someone wanting to dive into that.

One general coding recommendation is to avoid things like tasmota.delay(500) for more than a max of 50 ms, as it is completely blocking, not letting anything else proceed while you halt Tasmota. There is no multithreading, and you always have to exit quickly from Berry code to allow any activity in Tasmota to operate.

The preferred strategy to defer code till a bit later is to use tasmota.set_timer.