Eleven rooms, one honest answer to “is anyone in there?”

A DIY presence-sensing layer for the house: one small sensor node per room, each pairing a 24 GHz mmWave radar with a passive-infrared detector and a light sensor, talking to Home Assistant on the DECS Pi over the existing WiFi. No electronics on the person, no cameras, no cloud.

What you get

• Per room: an Occupied sensor that turns on within half a second of someone walking in and stays on while they sit still, read, or sleep. Type A rooms also give live x/y position of up to three people and up to three named zones (bed, sofa, stair head).
• Per node: light level in lux, WiFi signal, uptime, and on the wet-room nodes temperature and humidity.
• Whole house: House occupied, Upstairs / Downstairs occupied, Everyone asleep, and an estimated headcount, all built from the room sensors in Home Assistant.
• Automations ready to paste: lights that follow people and respect daylight, bathroom fans on humidity, a landing night path, heating setback for empty rooms through the Wunda climate entities, and a night-time part-arm of the GlobalGuard alarm with a cancel window.
• A Presence tab for the wall tablet that fits the existing home-panel build.

Design decisions, in one place

What it will not do

It will not tell two people apart. Radar cannot identify anyone; the Extras section shows how to add “who” using the phones you already carry. It will not reliably separate a large dog from a person on the Type B nodes. And a node aimed through a 100 mm stud wall will see the next room, so placement and zone filters matter more than any code.

Which node goes where, and what it drives

Seven Type A tracking nodes where position and zones earn their keep, four Type B presence nodes where a yes/no is all anyone needs.

Placement rules that decide whether this works

1. Aim at people, not at walls to other rooms. 24 GHz passes through plasterboard. A node facing a stud wall reports the neighbour.
2. Height 1.8–2.2 m, tilt 10–20° down. Keeps the beam over furniture and under the ceiling.
3. Nothing that moves in the beam. Ceiling fans, oscillating heaters, curtains at an open window, a washing-machine drum, a hanging plant near a radiator. Either move the node or draw a filter zone.
4. PIR wants a clear line of sight and no heat sources. Not above a radiator, not facing a window that gets low sun.
5. Keep 30 cm from mirrors and large metal (fridge, boiler). They act as radar mirrors and double the room.

How a footstep becomes a light switching on

Every decision happens locally. The node fuses its own sensors and publishes one clean Occupied signal; Home Assistant does the house-level reasoning and drives the things you already own.

Why fuse on the node and not in Home Assistant

A template in HA works, but it depends on the API connection and HA being up. Fusing on the ESP means the Occupied entity is a single binary sensor with one timestamp, HA's history is clean, and a node keeps sensible state through an HA restart. The raw PIR and radar entities are still exposed for tuning and for the state machine drawing above.

Timing design

Why radar plus PIR, and which radar

Each technology fails in a different way. Picking two with opposite failure modes is cheaper than picking one perfect sensor, because there isn't one.

Ready-made alternatives, priced for this house

If soldering eleven boards is not your idea of a good Saturday, these exist. Prices are UK retail in September 2026, rounded.

The parts, and the one gotcha on each

Bill of materials

Two node types, one order. Quantities are editable; totals recompute. AliExpress prices include UK VAT at checkout and assume you buy the multipacks; Amazon UK prices are for next-day single units.

Per-node parts

One-off tools and consumables

Node schematics

Both node types share one microcontroller pin map so a Type B is a Type A with a cheaper radar and one extra I²C part. Nothing here needs a custom PCB; every connection is a wire between module headers.

Pin map (both types)

Fallback board: ESP32 WROOM-32 DevKit (30-pin)

If a room turns out to have weak WiFi (porch, utility behind the boiler), swap the Super Mini for a WROOM-32 DevKit at £3.50. Better antenna, 1 A regulator, no transmit-power cap needed. Change only the board line and pin numbers in the firmware:

Power budget and supply

Everything runs at 5 V from a plug-in adapter. There is no mains work in this design, which keeps it inside what a homeowner may do without a Part P notification.

Current budget per node

Supply options

Protection and safety

• Over-current: the USB adapter's own current limit (typically 1.2–1.5 A) is the fuse. No additional fuse needed in Option 1.
• Isolation: all node electronics are SELV (< 60 V DC) behind a double-insulated adapter. Touch-safe; a plastic box is enough.
• Bathrooms: IET zones apply to mains, not to a 5 V node, but keep the adapter outside the bathroom. Run the USB lead through the wall or door frame from the landing socket, or put the adapter in the loft above the ceiling node. Never use a shaver socket adapter; they are current-limited transformers and brown out.
• Porch: IP-rated enclosure or a closed box under the soffit; adapter indoors, lead through the wall in a 6 mm hole sealed with silicone.
• Reverse polarity: impossible with USB-C; the radar cable is keyed.
• ESD: handle the LD2450 by the edges; its antenna side is bare and it is the most expensive part in the box.

Cable schedule

Wiring drawing and build order

The layout puts the radar at the front of the box with nothing in front of its antenna, the PIR lens through the front face, the lux window at the top edge, and the ESP at the back with its USB-C at the bottom.

Build order, per node

1. Flash first, solder second.

   Plug the bare ESP32-C3 into the PC, install the generic ESPHome firmware from web.esphome.io, get it on the WiFi. A board that will not take firmware goes back in the spares bag before you've soldered anything to it.

2. Fit the capacitors.

   C1 (100 µF) between 5V and GND pads, C2 (10 µF) between 3V3 and GND. Watch polarity: the stripe is negative. Bend them flat against the board.

3. Radar cable.

   Plug the JST lead into the radar. Cut the free ends to 8 cm, tin them, solder red → 5V, black → GND, yellow (radar TX) → GPIO5, green (radar RX) → GPIO4. Type B: white (OUT) → GPIO1.

4. I²C modules.

   BH1750: VCC → 3V3, GND → GND, SDA → GPIO6, SCL → GPIO7. Type B: AHT20 on the same four nets, wires twisted with the BH1750's. ADDR pin on the BH1750 left open (0x23).

5. PIR.

   AM312: VCC → 3V3, GND → GND, OUT → GPIO10. The middle pin is OUT on nearly all AM312 boards; check the silkscreen.

6. Bench test on the desk.

   Power from USB, OTA the real room config, watch the ESPHome log: I²C scan finds 0x23 (and 0x38), the radar firmware text sensor fills in, PIR toggles when you wave. Only now go near the enclosure.

7. Box it.

   Radar on the front with hot glue at the corners (never over the antenna), PIR lens through its hole, BH1750 at the top slot, ESP at the back with USB-C through the bottom cut-out. Loop the USB lead once inside as strain relief.

8. Label it.

   Room name and IP on the back with a label maker. Eleven identical boxes are not identical to Future You.

The box and where it goes on the wall

A single 3D-printed clamshell fits both node types. If you'd rather not print, a 90 × 60 × 28 mm ABS project box needs three holes and a slot.

The printed parts, in 3D

Six parts make the whole kit — the two-piece clamshell, two wall wedges, the bathroom corner bracket and the snap pegs. Drag to spin any of them, scroll to zoom, or just leave it turning. Every one is generated to exact size by parts.py and prints in PLA at 15 % infill.

Enclosure

Printable parts

Six STLs, generated by parts.py with the same manifold3d stack as the NoteCase, exported already in print orientation. Everything is in C:\envy\presence\stl\; the previews below are rendered straight from the geometry that was exported. Change a dimension in the parameter block at the top of the script and rerun it to get a new set with the geometric checks re-run.

File	What it is	Size mm	Filament	Print on	Ender time
enclosure-base.stl	Back half. Keyholes at 60 mm centres (entry circle at the bottom, slot up), ESP32-C3 rails and top stop, USB-C cut-out, lux slot in the top wall, six vent slots, snap groove.	92 × 62 × 20	≈ 26 g	back plate down	1 h 20
enclosure-lid.stl	Front half. 12 mm radar pocket frame with a gap for the JST lead, 9.8 mm PIR dome hole with a board frame behind it, 5 mm lip with a 0.4 mm snap rib. Fits the base with 0.2 mm clearance.	92 × 62 × 13	≈ 21 g	front face down	1 h 10
wedge-15.stl	Standard wall mount at 1.8–2.0 m. Peg holes on the sloped face at 60 mm centres, two countersunk holes for 3.5 mm wall screws. Flat back for Command strips.	84 × 54 × 17	≈ 30 g	wall face down	1 h 00
wedge-25.stl	Same wedge for a higher mount or a small room where the beam has to reach the floor sooner.	84 × 54 × 28	≈ 40 g	wall face down	1 h 25
corner-bracket.stl	Bathrooms. Sits in the wall-wall corner under the ceiling, presents a face at 45° to both walls tilted 25° down. Hollow with vertical ribs, two wall screws at 50 mm from the corner with 7.8 mm counterbores, optional ceiling screw through the centre column. Box corners clear both walls by 1.5 mm and the ceiling by 3 mm.	107 × 107 × 50	≈ 70 g	ceiling face down	3 h 10
peg.stl	Hanging peg for the wedge and bracket: 6.6 mm head, 3.4 mm shank, press-fit tail into the 3.6 mm holes with a drop of superglue. Or use M3 × 12 screws with nuts in the wedge instead.	7 × 7 × 11	≈ 0.2 g	head down	10 min (×4)

Print settings

• 0.2 mm layers, 3 walls, 15 % infill, no supports for every part. The bracket's sloped face is a 25° overhang and prints clean; the snap rib on the lid is a 0.4 mm overhang and needs no help.
• PLA indoors, PETG for the porch node and the bathroom brackets (steam and summer sun both soften PLA).
• Test the snap on the first pair: the lip is 0.2 mm smaller than the base opening per side and the rib sits 0.1 mm inside its groove. If your printer runs tight, scale the lid 100.3 % in X and Y; if loose, 99.7 %.
• Peg holes are 3.6 mm and print at about 3.4, which is the peg diameter: push in with a drop of superglue. If a peg won't go, run a 3.5 mm drill through the hole.

How the parts go together

1. Flat wall at 1.9 m: two 3.5 mm screws 60 mm apart, heads 3 mm proud. Lower the base onto them. No wedge.
2. Wall with tilt: screw the wedge to the wall (or stick it with two Command strips), press two pegs into its face, lower the base onto the pegs.
3. Bathroom ceiling corner: hold the bracket in the corner against the ceiling, mark and drill the two wall holes 50 mm from the corner and 40 mm below the ceiling, screw it in, pegs, hang the base. The face already points 45° across the room and 25° down.
4. Wire, test, then press the lid on until it clicks. It comes off with a fingernail at the USB-C notch.

Room-by-room mounting notes

ESPHome configuration

Three shared files and one eleven-line file per room. The room file only carries substitutions, so a firmware fix is one edit and eleven OTA pushes.

Files on the Pi

Room file generator

secrets.yaml (add these keys)

presence-common.yaml

presence-ld2450.yaml (Type A)

presence-ld2410.yaml (Type B)

Build and flash workflow on the Pi

Eleven nodes deserve the ESPHome dashboard rather than one-off docker run lines. It is the same image you already use for the alarm bridge, left running on port 6052 with the host network so it can reach 192.168.5.x. It idles at about 100 MB; compiles are the only heavy moment, so do them one at a time and not during a TRADEPIT cron.

1. First flash over USB from the Envy PC.

   Open web.esphome.io in Chrome, plug the bare ESP32-C3 in, choose “Prepare for first use”, then “Connect to Wi-Fi” and pick the mesh SSID. The board gets a DHCP address on 192.168.5.x and shows up in the dashboard's discovered list within a minute.

2. Adopt it with the right room file.

   In the dashboard, open the room's card, Install → Wirelessly, and pick the discovered address. The node reboots onto its static IP with the real firmware. From here on every update is one click.

3. Watch the first log.

   Logs → the I²C scan lists 0x23 (and 0x38 on Type B), the radar firmware text sensor fills in, and PIR flips when you wave. Any one missing is a wiring fault, and you have not put the lid on yet.

4. Add to Home Assistant.

   Settings → Devices & services: ESPHome discovers each node on the Pi's wlan0. If discovery is slow, Add integration → ESPHome → host = the static IP, port 6053, paste the API key.

Integration, house logic and automations

Everything below lives in one package file so it can be dropped in, backed up and removed as a unit. Entity names follow from the friendly names in the room files, so nothing needs renaming.

Entities each node creates

Enable packages once

The presence package

Fill in the four placeholders marked TODO: light entity ids, the two fan switches, the Wunda climate entities and your phone's notify service. Everything else is ready. Check with Developer tools → YAML → Check configuration, then reload.

Notes on the logic

• Living room and bedrooms never switch on automatically. People choose their own lighting there; presence only turns it off after a long vacancy. The transit rooms, kitchen, utility, bathrooms and porch are fully automatic.
• Disarm is never automatic. Part-arm at night is the only alarm action, and it can be cancelled from the phone. The intruder automation only notifies; the panel remains the authority.
• Heating setback snapshots the setpoint so it restores to exactly where Wunda's schedule had it, and clears the snapshot so a schedule change later is not overwritten.
• Everyone Asleep uses moving-target counts, not just occupancy: a person reading in bed is “occupied, still”. Ten minutes of still plus an empty downstairs after ten at night is a good enough definition for arming.
• Porch is excluded from House Occupied so a courier does not count as someone home.

A Presence tab for home-panel

One tile per room that glows when occupied, a house summary row, the four control toggles, and a live radar map card for any Type A room. The map is a tiny custom card, registered the same way as the swipe-gesture module already on the panel.

Live radar map card

Draws the sensor at the bottom centre, its ±60° field of view, a 1 m grid, the three zones from the node's number entities, and each tracked target as a dot with its distance. Copy to /config/www/presence-map.js and register it as a module resource next to panel-gestures.js.

The view

Add ("presence","Presence","mdi:motion-sensor") to the TABS list in the panel builder and append this view to the tabs source. Tiles use custom:button-card, already installed on the panel; swap the styles for the decs_tile template if you want them to match exactly.

Bring-up, tuning and acceptance tests

Do one room end-to-end before building the other ten. The living room is the best first room: big, a sofa to sit still on, and you'll notice immediately if it is wrong.

Order of work

1. Pi side, once.

   ESPHome dashboard container up, secrets in place, the four shared files and the eleven room files copied in. Reserve 192.168.5.130–140 on the Tenda for the nodes' MACs as they appear; the static IPs in firmware keep working even before you do.

2. Living room node on the bench.

   Flash, adopt, watch the log, add to HA. Confirm the entities from the Home Assistant section exist and Occupancy follows you.

3. Mount and aim.

   Command strips first; screws once you're happy. Aim per the mounting table. Sit on the sofa, watch Target 1 X/Y for a minute: numbers steady and non-zero means the radar has you still.

4. Draw the zones.

   Stand at each corner of the sofa, note X and Y, add 300 mm margin, type the four numbers into the Zone 1 X1/Y1/X2/Y2 numbers. Watch Zone 1 Count go to 1 when you sit. Repeat for zone 2. Leave Zone Type at Disabled: zone counts are computed on the node and work regardless.

5. Only if something moves in the beam, use Filter.

   Set Zone Type to Filter and draw the moving object (curtain, fan) as a zone. In Filter mode all three zones exclude, so bed and sofa counting then has to be done in HA from Target X/Y with a template. Prefer moving the node.

6. Set the hold.

   Default 120 s in living/bedrooms, 60 s kitchen/bathrooms, 30 s hall/landing. Raise it if lights ever drop while you are sitting still; lower it if a room stays occupied long after you left.

7. Radar housekeeping.

   Multi Target on. Radar Timeout 5 s. Radar Bluetooth off. Type B: Engineering Mode on, walk the room, read the gate energies, set each gate's move/still threshold 10–15 above its empty-room energy, Max Move/Still Gate to the room's depth, Engineering Mode off.

8. Acceptance tests, then the next room.

   Run the five tests below, log the results in the table on the wall of the room in your head, and only then solder node number two.

Acceptance tests per room

Checklist before calling a room done

• Label on the back with room and IP; Tenda reservation made.
• ESPHome device shows “online” in the dashboard and HA; WiFi signal better than −75 dBm.
• Zones drawn and named in the entity registry (rename Zone 1 Count → “Sofa count” etc. in HA, not in YAML).
• Hold set; automations for that room un-commented in the package.
• Lux calibration: cover the sensor and check it reads < 5, then shine a phone torch and see it jump. Set the dark threshold by reading the lux at the moment you'd normally reach for the switch.

When it misbehaves

Ordered by how often it actually happens.

Diagnostics you already have

• ESPHome dashboard → Logs streams the node live over the API, no USB needed.
• HA History for the raw PIR and Radar entities beside Occupancy shows which sensor held a room on.
• WiFi Signal and Uptime on every node; a sawtooth uptime is a rebooting board.
• The OUT pin binary sensor on Type B tells you whether the radar itself thinks someone is there, independent of the UART parsing.

What I would add next, and why

Separate from the core design on purpose. Each of these is optional, cheap, and builds on the nodes rather than replacing them. The first three are the ones I'd actually do.

Built on the presence nodes

Home Assistant project, more broadly

Suggested order

1. Living room node end-to-end (this pack, sections 6–13).
2. Remaining ten nodes, two or three an evening.
3. UPS and backups, same week.
4. Bluetooth proxies and phone BLE, one evening.
5. Door contact and leak probes while the nodes are still fresh in your hands.
6. Heat-map and energy automations once there are two weeks of history to look at.

The same node, six upgrades layered on top

Everything here builds on the Rev A/B pack above: same ESP32-C3, same pin map, same room files, same Home Assistant package. Nothing already built has to change. Two additions are firmware only, two are optional hardware for specific rooms, one is a set-up tool, one is a Bluetooth switch-on.

How the versions stack

Order of work

1. Firmware first: ten zones, fan rejection, Bluetooth proxy. One OTA per node from the dashboard, nothing to buy.
2. Map editor v2 on the panel, so the zones can be drawn rather than typed.
3. Quest scan once the map exists, because that is what it feeds.
4. Type A+ modules for the two big rooms when the LD6001s arrive.
5. Type C vision last, and only in the five rooms where dog-versus-person changes an outcome.

How it stacks up against a Shelly — and the 60 GHz option

The Shelly Presence Gen4 is the obvious shop-bought comparison: a 60 GHz radar with app-drawn zones at about £65 a room. The HLK-LD6001 is the module it is built around, and Rev C can drop it into the two rooms that ever hold a crowd — while every other room stays on the £6 24 GHz module.

Rev C parts

presence-ld6001.yaml (Type A+ radar package)

Drop-in for presence-ld2450.yaml in the room file. The module's own four zones are exposed too; the ten-rectangle package sits on top exactly as with the LD2450 because it only reads target coordinates. The LD6001 reports no per-target speed, so the fan test uses position change alone.

Lid variant

enclosure-lid-ld6001.stl is generated with python parts.py --ld6001: the radar pocket grows to 60.6 × 30.6 mm and moves to the lower left so the PIR frame stays put. Base, wedges, bracket and pegs are unchanged. Print it in place of the standard lid for the living room and kitchen nodes.

Ten editable zones, drawn on the panel, fans ignored

The LD2450's three-zone limit is only its own on-module region filter. Zone counting already happens on the ESP from target coordinates, so Rev C adds ten rectangles held in number entities, evaluated twice a second, plus a fan-rejection test, plus an optional polygon layer for the rooms a rectangle cannot follow.

How it works

• Each zone is four numbers (x1, y1, x2, y2 in mm, radar frame) stored on the node and restored across reboots. All four equal means "undefined" and it reports nothing. Edit them from HA, the map editor, or the Quest scan.
• Every 500 ms the node reads the three targets, drops any the fan test has rejected, and publishes a count and an occupancy sensor per zone. Occupancy holds 5 s so a target flickering on a boundary doesn't chatter.
• Fan rejection: a target whose speed stays non-zero while its position stays within 300 mm of where it first appeared, for 60 s, is a fan, a curtain, a plant by a radiator — excluded until it actually travels. A sleeper is not caught: their speed reads zero.
• Polygons (optional) use the TillFleisch external component for convex polygon zones written in YAML — the stair-head wedge, a seating area with the doorway cut out. The ten-rectangle layer still works on top because it only reads target coordinates.

Edits to the existing Rev A files

Map editor v2

The Rev A map card becomes an editor. Drag on empty space to create a zone in the first free slot, drag a corner to resize, drag the middle to move. Each change writes the four numbers to the node through Home Assistant, so it is live before you let go. Polygons and a scanned room outline draw underneath as read-only guides. To delete a zone, drag it down to nothing or set its four numbers equal.

The full presence-map.js v2 (drag logic, polygon and backdrop rendering) and the generated presence-zones10.yaml live in the Pi's /config/www and /home/decs/esphome — bump ?v=2 in the Lovelace resource when you replace v1.

Eleven Bluetooth ears, and the phones you carry

Every node's ESP32-C3 has Bluetooth 5. Switching on the proxy makes the house a BLE receiver grid; Bermuda in Home Assistant turns "which node hears this phone loudest" into "Linda is in the living room". This is the one thing no radar can do, and it costs nothing.

Set-up in Home Assistant

1. Install Bermuda from HACS and add the integration. It finds the ESPHome proxies by itself.
2. Put the nodes in Areas. Settings → Devices: assign each presence node to its room. Bermuda reports the Area of the loudest proxy, so this mapping is the whole calibration.
3. Phones. Companion app → Sensors → BLE Transmitter: enable, set to iBeacon, note the UUID. Add it in Bermuda. Android randomises the MAC; the beacon UUID is what Bermuda follows.
4. Anything else. A £3 BLE tag on a key ring, a Xiaomi thermometer, a watch: each becomes a device with an Area.
5. Combine with the radar. The template below names someone only when the radar also sees a person in that room, which removes the BLE wobble at boundaries.

Zones and a floor plan from the headset

After Space Setup, the Quest holds each room as labelled geometry: a floor outline, walls, and furniture as boxes tagged bed, couch, table, storage, door, window. The Meta Quest Browser hands that to a WebXR page served from the Pi; you point the controller at the sensor on the wall to fix the radar frame, and the zones are written to the node and the outline drawn behind the live radar map.

Doing a room

1. Space Setup on the headset for that room, marking the bed or sofa, tables, doors and windows. Five minutes.
2. Open https://192.168.0.111:8443/roomscan.html in the Quest Browser, accept the certificate once, pick the room, enter AR.
3. Point the controller at the node on the wall and pull the trigger. The page reports the hit height; it should match the mounting height.
4. Send. The zones appear on the node's number entities within a second and the map card shows the room outline behind the live dots.
5. Tidy on the map. A scanned couch zone is its footprint plus 300 mm; drag an edge in if the radar picks people up in the walkway beside it.

The Pi handler

The WebXR page (roomscan.html) does the geometry in the headset; this small HTTPS server on the Pi receives the scan, writes the zone numbers through the HA REST API and saves a backdrop file for the map card.

A module that says "dog", and never says anything else

The Grove Vision AI V2 runs its own person, dog and cat detector on a Himax WiseEye2 at 0.4 W and reports class, box and confidence over a serial line. No video leaves it, it has no radio, and the ESP32-C3 stays as it is. Clip it onto an existing node or build a room with it from the start; the firmware is the same either way.

What it adds and what it does not

Where it goes

Hall, landing, living room, kitchen, porch. Never bedrooms or bathrooms: radar and PIR already handle a still sleeper, and a lens there buys nothing. The porch module needs the outdoor-rated enclosure and faces the doormat, not the street.

presence-vision.yaml

Home Assistant fusion

Privacy, written down

• Inference on the module; only class, box and score cross the serial line. No frames are stored or sent, and the module has no radio.
• A visible LED lights whenever the module is powered, and a slide switch on the box cuts its 5 V. Off means blind, and the node keeps working without it.
• Not in bedrooms or bathrooms, by design rather than by setting.