Leaks and Climate

Leaks and Climate

Water where it shouldn't be, freezers and server rooms at the wrong temperature, damp bathrooms, and smoke. Recipes run from simple to advanced; ● marks are explained on the Home page. Entity IDs are examples: change them to yours.

• Water leak ●
• Leak not acknowledged ●●
• Freezer too warm ●●
• Freezer warm overnight ●●●
• Server room overheated ●●
• Bathroom humidity, on the card only ●●
• Smoke detected ●●●

---

Water leak

● Basic · State · priority, choosing the groups, an action button

The problem. A leak sensor under the sink, the washing machine, or the water heater has detected water. This one shouldn't wait: you want to hear it everywhere, at once, and be able to shut off the water from your phone.

Why this kind. One sensor, one state (on = wet): a State alert, with no delay. What makes it different from the garage door is everything around it:

• Priority Critical, so it's at the top of the card, gets through quiet hours, and on an iPhone is sent time-sensitive, through a Focus.
• Its own notifier groups: Phone, Persistent, and Speakers, rather than the defaults, so the house says it out loud.
• A tighter reminder schedule: every 5 minutes until someone acknowledges it.
• A button to close the main water valve.

In the UI (Add alert → State):

Field	Value
Name	Water Leak
Priority	Critical
Icon	mdi:water-alert
Entity	binary_sensor.kitchen_leak
State	on
Notifications → Use the default notifier groups	Off
Notifications → Notifier groups	Phone, Speakers, Persistent
Notifications → Use the default reminder schedule	Off
Notifications → Reminder schedule	5
Notifications → On message	Water detected by {{ subject_entity_name }}!
Notifications → Done message	{{ subject_entity_name }} is dry again.
Notifications → Notification buttons	Shut off water: valve.close_valve on valve.main_water

To import:

format: alert_redux
version: 1
alerts:
  - name: Water Leak
    kind: state
    priority: critical
    icon: mdi:water-alert
    entity_id: binary_sensor.kitchen_leak
    target_state: "on"
    notifier_groups: [Phone, Speakers, Persistent]
    reminder_schedule: [5]
    message: Water detected by {{ subject_entity_name }}!
    done_message: "{{ subject_entity_name }} is dry again."
    buttons:
      - label: Shut off water
        action:
          - action: valve.close_valve
            target:
              entity_id: valve.main_water

(In YAML, on must be quoted, or it's read as true.)

What you'll see. Immediately: a notification on every phone, an announcement on the speakers, and a persistent notification, each with Shut off water. Every five minutes, a reminder, until someone acknowledges it. Acknowledging it anywhere clears the phone notifications everywhere.

Variations.

• Several leak sensors: a group sensor (on if any is wet), or a generator over the moisture device class, one alert per sensor (so the message says which).
• A leak that's dried by the time you look still matters: Keeping Alerts Until Acknowledged.
• Escalate if nobody responds: the next recipe.

---

Leak not acknowledged

●● Intermediate · Alert state · escalation without an automation

The problem. The leak alert has been going for 15 minutes and nobody has acknowledged it. Perhaps nobody's home, or everyone's asleep with phones on silent. Time to get louder.

Why this kind. An Alert state alert watches another alert's state. Watching Water Leak for active (firing and unacknowledged), with For how long 15 minutes, gives "the leak has been ignored for 15 minutes", as an alert of its own: its own priority (Emergency), its own notifications, its own place on the card and in the history. As soon as anyone acknowledges the leak, it's no longer active, so the escalation ends by itself.

This is the Alert Redux way to escalate: no automation with a for:, no helper to reset.

In the UI (Add alert → Alert state):

Field	Value
Name	Leak Not Acknowledged
Priority	Emergency
Icon	mdi:water-alert
Alert	Water Leak
States	active
For how long	15 minutes
Notifications → Notifier groups	Phone, Speakers (Use the default notifier groups off)
Notifications → Reminder schedule	2 (Use the default reminder schedule off)
Notifications → On message	Nobody has acknowledged the water leak for 15 minutes!

To import (with the Water Leak alert it watches):

format: alert_redux
version: 1
alerts:
  - name: Water Leak
    kind: state
    priority: critical
    icon: mdi:water-alert
    entity_id: binary_sensor.kitchen_leak
    target_state: "on"
    notifier_groups: [Phone, Speakers, Persistent]
    reminder_schedule: [5]
    message: Water detected by {{ subject_entity_name }}!
    done_message: "{{ subject_entity_name }} is dry again."
    buttons:
      - label: Shut off water
        action:
          - action: valve.close_valve
            target:
              entity_id: valve.main_water
  - name: Leak Not Acknowledged
    kind: alert_state
    priority: emergency
    icon: mdi:water-alert
    alert: alert_redux.water_leak
    alert_states: [active]
    delay_on: "00:15:00"
    notifier_groups: [Phone, Speakers]
    reminder_schedule: [2]
    message: Nobody has acknowledged the water leak for 15 minutes!

If you've already imported Water Leak from the recipe above, importing this file leaves it as it is (it's identical) and adds the escalation.

What you'll see. After 15 unacknowledged minutes, an Emergency alert: on an iPhone it's sent as a critical notification, which sounds even in silent mode and Do Not Disturb (once you've allowed Critical Alerts for the app in iOS settings). Emergency is the top of the card, and pulses red while unacknowledged. Acknowledge Water Leak, and the escalation ends with it.

Variations.

• Send the escalation to someone else: a neighbour's phone in a group of its own.
• Escalate a latching leak alert too: watch active and latched, so the escalation carries on after the water has stopped, until someone has acknowledged it.
• More escalation patterns: Escalation and Supersession.

---

Freezer too warm

●● Intermediate · Threshold · hysteresis, a delay, missing data

The problem. The chest freezer in the garage is warming up: the door's ajar, or it has failed. Opening it for a minute warms the sensor, so short spikes don't count. And its wireless temperature sensor sometimes drops out for a few minutes.

Why this kind. A value above a limit: Threshold. Three settings make it dependable:

• Maximum −12 (°C), with hysteresis 2: it fires above −12, and ends only when the freezer is back down to −14. A freezer hovering around −12 doesn't fire the alert on and off.
• Delay before firing 20 minutes: the temperature must stay above −12 for 20 minutes, which a door opening doesn't do.
• No-data grace period 30 minutes: if the sensor drops out while the alert is firing, the alert carries on for 30 minutes instead of ending (and starting again, notifications and all, when the sensor comes back).

In the UI (Add alert → Threshold):

Field	Value
Name	Freezer Too Warm
Priority	Warning
Icon	mdi:fridge-alert
Value entity	sensor.freezer_temperature
Maximum	-12
Hysteresis	2
Delay before firing	20 minutes
No-data grace period	30 minutes
Notifications → On message	The freezer is {{ states('sensor.freezer_temperature') }} °C.
Notifications → Done message	The freezer is back to {{ states('sensor.freezer_temperature') }} °C.

To import:

format: alert_redux
version: 1
alerts:
  - name: Freezer Too Warm
    kind: threshold
    priority: warning
    icon: mdi:fridge-alert
    entity_id: sensor.freezer_temperature
    maximum: "-12"
    hysteresis: 2
    delay_on: "00:20:00"
    no_data_grace: "00:30:00"
    message: The freezer is {{ states('sensor.freezer_temperature') }} °C.
    done_message: The freezer is back to {{ states('sensor.freezer_temperature') }} °C.

What you'll see. The alert's value attribute always holds the current reading. On the card, the message updates as the temperature changes. If the sensor goes unavailable while the alert isn't firing, the alert is no_data, listed at the bottom of the card with the missing sensor, so a dead sensor isn't mistaken for a cold freezer.

Variations.

• An adjustable limit: Maximum {{ states('input_number.freezer_limit') }}.
• The fridge too: a second alert with Maximum 7 and a shorter delay, or both a Minimum and a Maximum for "too cold" as well.
• Warm at 3 a.m. and fine again by 7? The next recipe.

---

Freezer warm overnight

●●● Advanced · Threshold · keep until acknowledged

The problem. The freezer was warm for half an hour in the night (the door drifted open, then the kids shut it at breakfast) and the alert came and went while everyone slept. The food may still need checking, but nothing on the card says so.

Why this kind. The same Threshold alert, with Keep until acknowledged on. A firing that ends unacknowledged doesn't go back to idle: the alert is latched, still on the card, still reminding, until someone acknowledges it.

In the UI. Edit Freezer Too Warm and turn on Keep until acknowledged.

To import (as a change to the alert above, so with overwrite; in Developer tools, overwrite: true beside definitions):

format: alert_redux
version: 1
alerts:
  - name: Freezer Too Warm
    kind: threshold
    priority: warning
    icon: mdi:fridge-alert
    latching: true
    entity_id: sensor.freezer_temperature
    maximum: "-12"
    hysteresis: 2
    delay_on: "00:20:00"
    no_data_grace: "00:30:00"
    message: The freezer is {{ states('sensor.freezer_temperature') }} °C.
    done_message: The freezer is back to {{ states('sensor.freezer_temperature') }} °C.

What you'll see. In the morning the alert is on the card with a dashed border, saying when it stopped. Its reminders carry on ("Freezer Too Warm stopped firing 2 hours ago and hasn't been acknowledged."). Acknowledge it, and it's gone. If the freezer warms up again before then, it's the same alert firing again, and its count goes up.

Variations. More about latching, and when not to use it: Keeping Alerts Until Acknowledged.

---

Server room overheated

●● Intermediate · Threshold · a live card message, a short reminder schedule

From a real home: this is one of the author's own alerts, on the office that holds the servers.

The problem. The server cupboard is getting hot: the air conditioning has stopped, or someone shut the door.

Why this kind. Threshold with a Maximum of 80 °F and hysteresis 1. A Card message shows the live temperature on the card, separately from the notification text. Reminders every 5 minutes, because heat damage is quick.

In the UI (Add alert → Threshold):

Field	Value
Name	Server Room Overheated
Priority	Warning
Icon	mdi:thermometer-high
Value entity	sensor.server_room_temperature
Maximum	80
Hysteresis	1
Notifications → Reminder schedule	5 (Use the default reminder schedule off)
Notifications → On message	The server room is overheating!
Notifications → Card message	see the import file
Notifications → Reminder message	The server room has been overheating for {{ duration }}.
Notifications → Done message	The server room temperature is OK.

To import:

format: alert_redux
version: 1
alerts:
  - name: Server Room Overheated
    kind: threshold
    priority: warning
    icon: mdi:thermometer-high
    entity_id: sensor.server_room_temperature
    maximum: "80"
    hysteresis: 1
    reminder_schedule: [5]
    message: The server room is overheating!
    display_message: |-
      The server room is overheating!
      Server room temperature: {{ states('sensor.server_room_temperature') | round(1) }} °F.
    reminder_message: The server room has been overheating for {{ duration }}.
    done_message: The server room temperature is OK.

What you'll see. A Warning alert. The phone gets the short on message; the card shows the card message, and its temperature changes as you watch. Warning is the default quiet-hours threshold, so it gets through at night.

Variations.

• Minimum as well (say 50 °F) for a cupboard that can get too cold.
• A chain: warm (Notice), hot (Warning), shutdown imminent (Emergency), each superseding the one below: Escalation and Supersession.
• The author's own version has Voice assistants proxies on, so "Alexa, turn off server room overheated" acknowledges it: Voice Control.

---

Bathroom humidity, on the card only

●● Intermediate · Threshold · no notifications, a fan button

The problem. After showers, the bathroom stays damp, and mould follows. It's not worth a phone notification; it's worth a reminder on the hall tablet to switch the fan on or open the window.

Why this kind. Threshold, with Maximum 70 % and hysteresis 10, so it ends at 60 %. Delay before firing 15 minutes, because every shower makes it humid for a while. Notifier groups set to none: turning off Use the default notifier groups and choosing no groups means it notifies nobody, and only shows on the card. Informational priority keeps it at the bottom of the card.

In the UI (Add alert → Threshold):

Field	Value
Name	Bathroom Humid
Priority	Informational
Icon	mdi:water-percent
Value entity	sensor.bathroom_humidity
Maximum	70
Hysteresis	10
Delay before firing	15 minutes
Notifications → Use the default notifier groups	Off, with no groups chosen
Notifications → Use the default reminder schedule	Off, with the schedule empty
Notifications → On message	The bathroom is {{ states('sensor.bathroom_humidity') }} % humid. Run the fan?
Notifications → Notification buttons	Fan on: fan.turn_on on fan.bathroom_extractor

To import:

format: alert_redux
version: 1
alerts:
  - name: Bathroom Humid
    kind: threshold
    priority: informational
    icon: mdi:water-percent
    entity_id: sensor.bathroom_humidity
    maximum: "70"
    hysteresis: 10
    delay_on: "00:15:00"
    notifier_groups: []
    reminder_schedule: []
    message: The bathroom is {{ states('sensor.bathroom_humidity') }} % humid. Run the fan?
    buttons:
      - label: Fan on
        action:
          - action: fan.turn_on
            target:
              entity_id: fan.bathroom_extractor

What you'll see. No notifications at all: just an Informational box on the card with a Fan on button, which goes away when the humidity is back to 60 %.

Variations.

• A card on the bathroom's dashboard showing only this room's alerts: give the alert the Bathroom area and use the card's areas option (Building on Alert Redux).
• Or make it a generator over every humidity sensor in rooms with the label wet room.

---

Smoke detected

●●● Advanced · State + Alert state · unacknowledgeable, latching, supersession

The problem. A smoke or carbon monoxide alarm has gone off. While there is smoke, nobody should be able to make the alert go quiet with a tap: it should keep going until the detectors clear. But once they clear (it was burnt toast, or a real fire that's now out), the household should still have to see that it happened, especially if nobody was home.

Why this kind. Two alerts:

1. Smoke Detected: a State alert on the detectors, Emergency, with Acknowledgeable off. It can't be acknowledged or snoozed, from the card, phone, or voice. It reminds every 2 minutes for as long as there's smoke, and ends when the detectors clear.
2. Smoke Was Detected: an Alert state alert watching Smoke Detected for active, with Keep until acknowledged on. It fires with the first, and when the smoke clears it latches: it stays on the card and keeps reminding until someone acknowledges it.

Smoke Detected supersedes Smoke Was Detected, so while there's smoke the companion stays silent and folds under it on the card: you're told about the smoke once, not twice. (Propagation must stay Do nothing: acknowledgements can't be passed on to an alert that can't be acknowledged.)

In the UI (Add alert → State, then Add alert → Alert state):

Smoke Detected

Field	Value
Name	Smoke Detected
Priority	Emergency
Icon	mdi:smoke-detector-variant-alert
Entity / State	binary_sensor.smoke_detectors / on
Acknowledgeable	Off
Notifications → Notifier groups	Phone, Speakers, Persistent (Use the default notifier groups off)
Notifications → Reminder schedule	2 (Use the default reminder schedule off)
Notifications → On message	SMOKE DETECTED! Get everyone out.
Notifications → Done message	The smoke detectors have cleared.
Supersession → Supersedes	Smoke Was Detected, Do nothing to this alert

Smoke Was Detected (create this one first, so the first can supersede it)

Field	Value
Name	Smoke Was Detected
Priority	Critical
Icon	mdi:smoke-detector-variant
Alert	Smoke Detected
States	active
Keep until acknowledged	On
Notifications → Notifier groups	Phone, Persistent (Use the default notifier groups off)
Notifications → On message	Smoke was detected. Check the house, then acknowledge this alert. (the card shows it; it's never sent, since the alert is superseded while it fires)
Notifications → Reminder message	The smoke alarm went off, and cleared {{ duration }} ago. Check the house, then acknowledge this alert.

To import (both together; the order doesn't matter in a file):

format: alert_redux
version: 1
alerts:
  - name: Smoke Detected
    kind: state
    priority: emergency
    icon: mdi:smoke-detector-variant-alert
    acknowledgeable: false
    entity_id: binary_sensor.smoke_detectors
    target_state: "on"
    notifier_groups: [Phone, Speakers, Persistent]
    reminder_schedule: [2]
    message: SMOKE DETECTED! Get everyone out.
    done_message: The smoke detectors have cleared.
    supersedes:
      - alert: alert_redux.smoke_was_detected
  - name: Smoke Was Detected
    kind: alert_state
    priority: critical
    icon: mdi:smoke-detector-variant
    latching: true
    alert: alert_redux.smoke_detected
    alert_states: [active]
    notifier_groups: [Phone, Persistent]
    message: Smoke was detected. Check the house, then acknowledge this alert.
    reminder_message: >-
      The smoke alarm went off, and cleared {{ duration }} ago.
      Check the house, then acknowledge this alert.

What you'll see. While there's smoke: an Emergency alert with no Acknowledge or Snooze anywhere (the card shows none, the notification has none, and voice commands are refused), sent to iPhones as critical, through silent mode, every 2 minutes. When the detectors clear: "The smoke detectors have cleared.", and Smoke Was Detected latches, dashed on the card, reminding until someone acknowledges it. (It only reminds once latched: while it's firing, Smoke Detected supersedes it. And while it's latched, duration in its messages is how long ago it stopped.)

Variations.

• The same pair for carbon monoxide, or a gas leak.
• Without the companion, Smoke Detected alone is a good unacknowledgeable alert; the companion is what gives you the memory of it.
• Turn the lights on and unlock the doors when it fires: an automation triggered by the alert (Building on Alert Redux).