Bermuda with some small tweaks (per-room distance limits, temporal stability filtering, and unified device sensor)

[andreamag00]

Recently, I switched from ESPresense to Bermuda.

I find Bermuda exceptional, and I’d like to sincerely thank @agittins and share with you some of my customizations.

1) Maximum distance per room

It would be great to set a maximum distance from the Bluetooth proxy within which a detected device is considered to be in a room.
In my experience, this would be useful in several situations (e.g., a device in the garden being detected in the living room, a device on the lower floor being detected upstairs, homes where Bluetooth proxies are only present in certain rooms, etc.).

To implement this feature:

• I created an input_number for each room, allowing the user to adjust the maximum distance for that room via the UI.
• I created a template sensor that returns the room the device is in only if the distance is less than or equal to the input_number value for that room.

2) Tuning stability

• Some users rely on Bermuda for automations that require very fast detection (e.g., UI updates or lighting changes).
• Others use Bermuda for automations that prioritize stability over speed (e.g., I use Bermuda to control air conditioning and heating, where I want stable readings and am happy to ignore variations shorter than 30 seconds, which would otherwise introduce noise in the data).

So, I decided to add a time-based threshold to the existing Bermuda options: the Bermuda values (home, away, room change) are only confirmed if they remain stable for x seconds.

To implement this:

• I created an input_number that allows the user to set how long the new state (new room, away, home) must remain stable before being accepted (e.g., only after 30 seconds).
• I created a template sensor that returns the new value only if it has been stable for x seconds.

3) A single sensor

Bermuda provides two very useful sensors:

• Area sensor → returns the room name, or unknown (if the device is out of range based on Bermuda’s global max distance setting or not detected by any proxy).
• Device tracker sensor → returns home (if the device is detected by any proxy, even beyond the max distance) or not_home (if not detected by any proxy).

I thought it would be very useful to merge these into a single sensor.

So, I created a template sensor that returns:

• the room name → if Bermuda considers the device to be in a room
• home → if the device is beyond Bermuda’s max room range but still detected by some proxy (i.e., it’s in the house)
• not_home → if the device is not detected by any proxy (i.e., it’s outside the house)

Conclusion

By combining the ideas from sections 1, 2, and 3, I created a final template sensor (reached through two intermediate sensors, which I exclude from the database to avoid generating unnecessary data) that returns:

• the room name → if the device is within the room’s max distance and the change is stable for x seconds
• home → if the device is inside the house (detected by any proxy), but beyond the maximum range of all rooms
• not_home → if the device is outside the house (not detected by any proxy)

UI

Code

#################
#### HELPERS ####
#################

input_number:
  # delay per conferma stanza
  bermuda_delay_per_conferma_stanza:
    name: "bermuda - delay per conferma stanza"
    min: 1
    max: 120
    step: 1
    unit_of_measurement: "sec"
    icon: mdi:timer
  # soglie di distanza per ciascuna stanza (ho inserito solo le stanze in cui ci sono bluetooth proxy; come max lascio 20 che è anche la soglia definita di default in Bermuda)
  bermuda_distanza_massima_app_10_soggiorno:
    name: "bermuda - distanza massima - app 10 - soggiorno"
    min: 1
    max: 15
    step: 0.1
    unit_of_measurement: "m"
    icon: mdi:signal-distance-variant
  #
  # ... others input_number for every other room
  #

##########################
#### TEMPLATE SENSORS ####
##########################

template:
  #
  ######################################################
  #### TRIGGER PER RICALCOLO SENSORI OGNI X SECONDI ####
  ######################################################
  #
  # Per far sì che il sensore di ciascun dispositivo (ad es iphone di Andrea) venisse ricalcolato ogni x secondi (dove x è un valore dinamico che coincide con "input_number.bermuda_delay_per_conferma_stanza"):
  # • originariamente avevo pensato di configurare il sensore di ciascun dispositivo come template sensor in cui inserire un time_trigger che scatta con seconds: seconds: "{{ states('input_number.bermuda_delay_per_conferma_stanza') | int(15) }}"
  #   Tuttavia questa soluzione non funziona perchè seconds viene fissato una sola volta in startup di home assistant e non anche in runtime, come la conseguenza che:
  #   - se dopo l'avvio di home assistant cambio input_number.bermuda_delay_per_conferma_stanza, il valore del time_trigger non si aggiorna fino al prossimo riavvio
  #   - spesso all'avvio di home assistant il template sensor viene calcolato prima del calcolo di input_number.bermuda_delay_per_conferma_stanza con il risultato di ricevere un errore o il valore di fallback
  # • quindi ora ho adottato un altro approccio basato su due sensori:
  #   - ho creato un template binary sensor che dà come valore on tutte le volte che i secondi attuali sono divisibili per il valore di input_number.bermuda_delay_per_conferma_stanza (ad esempio se input_number.bermuda_delay_per_conferma_stanza ha valore 25, il template bynary sensor dà valore on tutte le volte che il numero dei secondi è divisibile per 25)
  #   - quindi nel sensore finale di ciascun dispositivo, ho messo un apposito trigger, in modo che il sensore finale viene rivalutato ogni volta che il template binary sensor di cui alla riga precedente dà come valore on
  #
  - trigger:
      - trigger: time_pattern
        seconds: "/1"
    binary_sensor:
      - name: "bermuda - ricalcolo dei dispositivi"
        unique_id: "bermuda_ricalcolo_dei_dispositivi"
        state: >-
          {%- set orario_attuale = as_timestamp(now()) -%}
          {%- set delay = states('input_number.bermuda_delay_per_conferma_stanza') -%}
          {%- if orario_attuale in ['unknown','unavailable',none]
          or delay in ['unknown','unavailable',none] -%}off
          {%- else -%}
            {%- if (orario_attuale | float | round(0)) % (delay | float | round(0)) == 0 -%}on
            {%- else -%}off
            {%- endif -%}
          {%- endif -%}
  #
  #
  ##########################
  #### IPHONE DI ANDREA ####
  ##########################
  #
  # 1 - calcolo distanza massima in base alla stanza (template sensor che, in base alla stanza attuale, individua la distanza massima impostata
  #
  - sensor:
      - name: "bermuda - iphone di andrea - distanza massima"
        unique_id: "bermuda_iphone_di_andrea_distanza_massima"
        state: >-
          {# creo una variabile per la stanza attuale #}
          {%- set stanza_attuale = states('sensor.private_ble_device_iphone_di_andrea_area') -%}
          {# creo una variabile per la distanza massima di ciascuna stanza #}
          {%- set dist_max_app_10_sogg = states('input_number.bermuda_distanza_massima_app_10_soggiorno') -%}
          {%- set dist_max_app_10_studio_ale = states('input_number.bermuda_distanza_massima_app_10_studio_ale') -%}
          {%- set dist_max_app_9_camera_ale = states('input_number.bermuda_distanza_massima_app_9_camera_ale') -%}
          {%- set dist_max_app_9_camera_andrea = states('input_number.bermuda_distanza_massima_app_9_camera_andrea') -%}
          {%- set dist_max_app_9_camera_m_e_p = states('input_number.bermuda_distanza_massima_app_9_camera_mamma_e_papa') -%}
          {%- set dist_max_app_9_cucina = states('input_number.bermuda_distanza_massima_app_9_cucina') -%}
          {%- set dist_max_app_9_studio_alberto = states('input_number.bermuda_distanza_massima_app_9_studio_alberto') -%}
          {# creo una fallback a 'unavailable' nel caso di valori non corretti #}
          {%- if stanza_attuale in ['unknown','unavailable',none] 
          or dist_max_app_10_sogg in ['unknown','unavailable',none]
          or dist_max_app_10_studio_ale in ['unknown','unavailable',none]
          or dist_max_app_9_camera_ale in ['unknown','unavailable',none]
          or dist_max_app_9_camera_andrea in ['unknown','unavailable',none]
          or dist_max_app_9_camera_m_e_p in ['unknown','unavailable',none]
          or dist_max_app_9_cucina in ['unknown','unavailable',none]
          or dist_max_app_9_studio_alberto in ['unknown','unavailable',none] -%}{{'unavailable'}}
          {# se tutti i valori sono corretti, calcolo la distanza massima #}
          {%- else -%}
            {# creo un dizionario con tutte le distanze massime #}
            {%- set distanze_massime = {
              'app 10 - soggiorno' : dist_max_app_10_sogg,
              'app 10 - studio ale' : dist_max_app_10_studio_ale,
              'app 9 - camera ale' : dist_max_app_9_camera_ale,
              'app 9 - camera andrea' : dist_max_app_9_camera_andrea,
              'app 9 - camera mamma e papà' : dist_max_app_9_camera_m_e_p,
              'app 9 - cucina' : dist_max_app_9_cucina,
              'app 9 - studio alberto' : dist_max_app_9_studio_alberto,
            } -%}
            {# calcolo la distanza massima in base alla stanza attuale, con un fallback di a 'unavailable' #}
            {{ distanze_massime[stanza_attuale] if stanza_attuale in distanze_massime else 'unavailable' }}
          {%- endif -%}
  #
  # 2 - conferma distanza < distanza massima (un template bynary sensor on-off identifica se la distanza attuale è sotto la distanza massima)
  #
  - binary_sensor:
      - name: "bermuda - iphone di andrea - distanza inferiore a distanza massima"
        unique_id: "bermuda_iphone_di_andrea_distanza_inferiore_a_distanza_massima"
        state: >-
          {%- set distanza_attuale = states('sensor.private_ble_device_iphone_di_andrea_distance') -%}
          {%- set distanza_massima = states('sensor.bermuda_iphone_di_andrea_distanza_massima') -%}
          {%- if distanza_attuale in ['unknown','unavailable',none]
          or distanza_massima in ['unknown','unavailable',none] -%}off
          {%- else -%}
            {%- if (distanza_attuale | float) < (distanza_massima | float) -%}on
            {%- else -%}off
            {%- endif -%}
          {%- endif -%}
  #
  # 3 - sensor finale
  # Il sensore restituisce:
  # • la stanza individuata da Bermuda -> se 1) la stanza è stabile da almento x secondi AND 2) se la distanza è sotto la distanza massima da almeno x secondi
  # • home -> se il dispositivo è in casa ma oltre la distanza massima impostata per la stanza
  # • not_home -> se il dispositivo non è rilevato da nessun bluetooth proxy
  #
  - trigger:
      # trigger 1
      # Scatta il trigger (cioè il sensore viene rivalutato) se Bermuda rileva
      # • un cambiamento della stanza (sensor.private_ble_device_*_area cambia)
      # • stabile per x secondi (dove x corrisponde a input_number.bermuda_delay_per_conferma_stanza)
      # L'unico difetto è che forse for: seconds: viene impostato una volta per tutte solo all'avvio di home assistant e, per riflettere nuovi valori di input_number.bermuda_delay_per_conferma_stanza, bisogna riavviare home assistant (ma mi sembra un difetto accettabile)
      - trigger: state
        entity_id: sensor.private_ble_device_iphone_di_andrea_area
        for:
          seconds: "{{ states('input_number.bermuda_delay_per_conferma_stanza') | float(30) | round(0) }}"
      # trigger 2
      # Scatta il trigger (cioè il sensore viene rivalutato) se home assistant rileva
      # • un cambiamento sopra o sotto la distanza massima della stanza (binary_sensor.bermuda_iphone_di_*_distanza_inferiore_a_distanza_massima cambia)
      # • stabile per x secondi (dove x corrisponde a input_number.bermuda_delay_per_conferma_stanza)
      # L'unico difetto è che forse for: seconds: viene impostato una volta per tutte solo all'avvio di home assistant e, per riflettere nuovi valori di input_number.bermuda_delay_per_conferma_stanza, bisogna riavviare home assistant (ma mi sembra un difetto accettabile)
      - trigger: state
        entity_id: binary_sensor.bermuda_iphone_di_andrea_distanza_inferiore_a_distanza_massima
        for:
          seconds: "{{ states('input_number.bermuda_delay_per_conferma_stanza') | float(30) | round(0) }}"
      # trigger 3
      # Scatta il trigger (cioè il sensore viene rivalutato) quando binary_sensor.bermuda_ricalcolo_dei_dispositivi diventa on
      # (ricordo che binary_sensor.bermuda_ricalcolo_dei_dispositivi, sensore sopra creato, diventa on ogni x secondi dove x corrisponde a input_number.bermuda_delay_per_conferma_stanza)
      - trigger: template
        value_template: >-
          {{ is_state('binary_sensor.bermuda_ricalcolo_dei_dispositivi','on') }}
      # trigger 4
      # Scatta il trigger (cioè il sensore viene rivalutato) quando home assistant termina il prcesso di startup (l'ho aggiunto per far sì che il sensore abbia subito uno stato valido)
      - trigger: homeassistant
        event: start
    sensor:
      - name: "bermuda - iphone di andrea - stanza"
        unique_id: "bermuda_iphone_di_andrea_stanza"
        icon: mdi:cellphone-nfc
        state: >-
          {%- set stanza_attuale = this.state -%}
          {%- set stanza_nuova = states('sensor.private_ble_device_iphone_di_andrea_area') -%}
          {%- set distanza_inferiore_a_dist_max = states('binary_sensor.bermuda_iphone_di_andrea_distanza_inferiore_a_distanza_massima') -%}
          {%- set orario_attuale = as_timestamp(utcnow()) -%}
          {%- set orario_ultima_modifica_stanza = as_timestamp(states.sensor.private_ble_device_iphone_di_andrea_area.last_changed) -%}
          {%- set orario_ultima_modifica_dist_inferiore_a_dist_max = as_timestamp(states.binary_sensor.bermuda_iphone_di_andrea_distanza_inferiore_a_distanza_massima.last_changed) -%}
          {%- set secondi_per_stato_stabile = states('input_number.bermuda_delay_per_conferma_stanza') | float -%}
          {%- set device_tracker = states('device_tracker.private_ble_device_iphone_di_andrea_bermuda_tracker') -%}
          {# per prima cosa verifichiamo di avere valori corretti, con una precisazione: Bermuda [stanza_nuova], se rileva un dispositivo in casa ma oltre il proprio raggio, lo identifica con 'unknown', quindi bisogna escludere 'unknown' dai controlli per il sensore Bermuda in modo da poterlo considerare un valore valido e maneggiarlo dopo #}
          {%- if stanza_nuova in ['unavailable',none]
          or distanza_inferiore_a_dist_max in ['unknown','unavailable',none]
          or orario_attuale in ['unknown','unavailable',none]
          or orario_ultima_modifica_stanza in ['unknown','unavailable',none]
          or orario_ultima_modifica_dist_inferiore_a_dist_max in ['unknown','unavailable',none]
          or secondi_per_stato_stabile in ['unknown','unavailable',none]
          or device_tracker in ['unknown','unavailable',none] -%}
            {# se i controlli falliscono restituisci il valore attuale o, in subordine, 'unavailable' #}
            {{ stanza_attuale if stanza_attuale not in ['unknown',none] else 'unavailable' }}
          {%- else -%}
            {# se i valori sono corretti verifica se i valori sono stabili #}
            {# se i valori sono stabili adotta un nuovo valore #}
            {%- if orario_attuale - orario_ultima_modifica_stanza >= secondi_per_stato_stabile and
            orario_attuale - orario_ultima_modifica_dist_inferiore_a_dist_max >= secondi_per_stato_stabile -%}
              {# adotta la nuova stanza solo se siamo sotto la distanza massima e Bermuda non restituisce unknown; altrimenti prendi home/not_home da device_tracker #}
              {{ stanza_nuova if (distanza_inferiore_a_dist_max == 'on' and stanza_nuova != 'unknown') else device_tracker }}
            {# se i valori non sono stabili mantieni il vecchio valore #}
            {%- else -%}
              {{ stanza_attuale if stanza_attuale not in ['unknown',none] else 'unavailable' }}
            {%- endif -%}
          {%- endif -%}

  #
  # ... others template sensor for every other device
  #

[agittins]

Great stuff, @andreamag00 ! This is exactly how to take the existing sensors and "bend them to your will" :-)

Bermuda tries to give data that is the "most reponsive, even if inaccurate", the idea being that you can always apply filters to calm it down, but you can never "restore" that responsiveness after it's filtered out.

I do plan to move a number of settings to be able to be "per device" or "per proxy" by using disabled-by-default sensors, which will hopefully simplify some of these tasks, but what you've done is in my opinion exactly the right way to approach these sorts of customisation, and thanks for sharing your solutions with everyone!

[andreamag00]

Thank you for creating Bermuda! It’s outstanding!!

[agittins]

Cheers! Much appreciated 😁