RFID Cat-Door Tracker — Project Plan & Build Guide¶

Use the RFID collar tags that came with the PetLibro feeder + Dockstream fountain to know, in Home Assistant, which cat went through the cat door and which way — in or out. An ESPHome microcontroller at the door reads the tag and publishes the passage to HA, which keeps each cat's indoor/outdoor status, fires a push notification, and logs the history.

How it works¶

        OUTSIDE                CAT DOOR                INSIDE
                          ┌──────────────────┐
                          │   flap aperture   │
       cat approaches  →  │  ╔════════════╗  │  → cat enters
                          │  ║ RFID coil   ║  │
                          │  ║ antenna ring║  │     collar tag passes
                          │  ╚════════════╝  │     through the coil
                          │   IR beam OUT ─┐ │
                          │   IR beam IN  ─┘ │  ← "which beam first" = direction
                          └────────┬─────────┘
                                   │ USB power + WiFi
                              ┌────▼─────┐
                              │  ESP32   │  reads tag UID (who)
                              │ (ESPHome)│  + beam order (which way)
                              └────┬─────┘
                                   │ local ESPHome API
                                   ▼
                            Home Assistant
              per-cat indoor/outdoor status · push alert · history

1. As a cat passes through the flap, its collar tag couples with a coil antenna wrapped around the door aperture (the same trick SureFlap uses) → the reader emits the tag's UID.
2. A tag UID maps to a cat (you pair each tag once).
3. A cheap direction gate (two IR break-beams, or the simpler options below) tells in vs out.
4. The ESP32 runs ESPHome, talks to HA over the local encrypted API (no cloud), and HA does the rest: updates each cat's status, notifies, and records the passage.

Step 0 — Identify your tag (do this FIRST)¶

Everything downstream (which reader to buy, the antenna, the firmware) depends on the tag's frequency and encoding. PetLibro states the collar tag "does not support microchips," which rules out the 134.2 kHz FDX-B pet-microchip standard and strongly points to a proprietary 125 kHz LF tag — but confirm before buying a reader.

How to identify it, easiest first:

The rest of this guide assumes the likely 125 kHz EM4100 outcome and notes where a different result changes things.

The hard part — telling "in" from "out"¶

A single RFID reader knows who, never which way. Pick one of these, simplest first:

Recommendation: build the IR beam gate. It separates the two jobs — RFID = who, beams = which way — so each is simple and each is reliable. You can also cross-check passages against the new Cat Camera if it covers the door.

Bill of materials¶

Total ≈ $30–45 on top of the reused ESP32. Borrowing a Flipper Zero for Step 0 saves buying the wrong reader.

Antenna — the make-or-break part¶

Low-frequency RFID has a short read range (a few cm), so the tag must pass close to the antenna. The reliable trick (how commercial cat flaps do it) is a coil ring around the flap aperture so the tag passes through the coil:

• Wind ~30–60 turns of enamelled magnet wire in a flat ring framing the opening (tape it to the tunnel, or route through a slim 3D-printed channel).
• The coil + a parallel capacitor form a tuned circuit; aim for resonance at 125 kHz. Start near the reader's recommended value and adjust the cap (1–10 nF range) for the strongest, most consistent read across the whole opening.
• Keep the coil away from metal (metal detunes and shields it). If the door frame is metal, stand the coil off it.
• Test read range with the actual collar tag at several heights/angles — the collar hangs under the chin, so the tag sweeps the lower third of the opening as the cat ducks through. Place the coil to catch that zone.

Wiring (recommended: reader + beam gate)¶

The coil antenna connects to the RDM6300's antenna terminals (with its tuning cap), not to the ESP32.

ESPHome firmware¶

Create the device in Home Assistant → ESPHome → New Device, named cat-door. Base config (same api/ota/wifi pattern as the food-temp build):

substitutions:
  name: cat-door
  friendly_name: Cat Door

esphome:
  name: ${name}
  friendly_name: ${friendly_name}

esp32:
  board: esp32dev

logger:                     # needed to read unknown tag UIDs on first pass
api:
  encryption:
    key: !secret cat_door_api_key
ota:
  - platform: esphome
    password: !secret ota_password
wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  ap:
    ssid: "Cat-Door Fallback"
captive_portal:

uart:
  id: uart_rfid
  rx_pin: GPIO16
  baud_rate: 9600           # RDM6300 default

rdm6300:
  uart_id: uart_rfid

First pass — learn each cat's UID. With just the block above, flash the board, then wave each collar tag past the coil and read the ESPHome logs:

[rdm6300]: RDM6300 Tag: '1234567' (...)

Note the decimal UID per cat. Then add a binary_sensor per known tag plus the two direction beams:

binary_sensor:
  # ---- known cats (fill in real UIDs from the logs) ----
  - platform: rdm6300
    uid: 1234567
    name: "Cat Door — Mittens tag"
    id: tag_mittens
  - platform: rdm6300
    uid: 7654321
    name: "Cat Door — Smokey tag"
    id: tag_smokey

  # ---- direction gate ----
  - platform: gpio
    pin: { number: GPIO18, mode: INPUT_PULLUP, inverted: true }
    name: "Cat Door Beam Outer"
    id: beam_outer
  - platform: gpio
    pin: { number: GPIO19, mode: INPUT_PULLUP, inverted: true }
    name: "Cat Door Beam Inner"
    id: beam_inner

  - platform: status
    name: "Cat Door Status"     # online/offline health

Each tag_* turns on while its collar is in the field and off when it leaves — that's the per-cat passage signal HA keys on. The beams expose the direction. (Add the direction state-machine in ESPHome with globals + on_press if you prefer it on-device; doing it in HA, below, keeps it tweakable without re-flashing.)

Home Assistant integration¶

ESPHome auto-discovers — accept the device and you get binary_sensor.cat_door_mittens_tag, ..._smokey_tag, binary_sensor.cat_door_beam_outer/_inner, and binary_sensor.cat_door_status.

Add one indoor/outdoor helper per cat (in configuration.yaml):

input_boolean:
  cat_mittens_indoors:
    name: "Mittens — Indoors"
    icon: mdi:cat
  cat_smokey_indoors:
    name: "Smokey — Indoors"
    icon: mdi:cat

And a per-cat passage automation that reads direction from which beam broke last, sets the status, and notifies (one per cat; Mittens shown):

- alias: "Cat Door — Mittens Passage"
  id: cat_door_mittens
  triggers:
    - trigger: state
      entity_id: binary_sensor.cat_door_mittens_tag
      to: "on"
  action:
    - variables:
        # whichever beam is currently broken (or broke most recently) gives direction
        going_out: "{{ is_state('binary_sensor.cat_door_beam_outer','on') }}"
    - choose:
        - conditions: "{{ going_out }}"
          sequence:
            - action: input_boolean.turn_off
              target: { entity_id: input_boolean.cat_mittens_indoors }
            - action: notify.mobile_app_louis_iphone
              data:
                title: "🐈 Mittens went out"
                message: "Left through the cat door just now."
                data: { tag: "cat_door_mittens", group: "cat_door" }
        - conditions: "{{ not going_out }}"
          sequence:
            - action: input_boolean.turn_on
              target: { entity_id: input_boolean.cat_mittens_indoors }
            - action: notify.mobile_app_louis_iphone
              data:
                title: "🐈 Mittens came in"
                message: "Back inside through the cat door."
                data: { tag: "cat_door_mittens", group: "cat_door" }
  mode: single

Useful automations to layer on¶

• "Out too long" at night — if any cat_*_indoors is off after, say, 10 PM for > 2 hours, notify both phones (mirrors the household alert style in Notifications).
• Everyone-in confirmation — a bedtime check: announce which cats are still out.
• Door-left-ajar / stuck-open — if a beam stays broken for minutes, the flap may be propped; alert.
• Curfew nudge — at dusk, if a cat is out, ping a reminder.

Dashboard¶

Add a Cat Door card to the Command dashboard (or the Cat Camera area): a per-cat row showing 🏠 In / 🌳 Out from input_boolean.cat_*_indoors, the last passage time, and a mini logbook of recent in/out events. Pairs naturally next to the Cat Camera tile.

Power, mounting & weatherproofing¶

• Continuous 5 V USB — the reader polls constantly; batteries are a non-starter. Run a USB cable to the nearest outlet.
• Mount the ESP32 in a project box beside the door; keep the coil at the aperture and the box away from the metal frame.
• Exterior door: use a weatherproof (IP65) box, gland the cable, and keep the ESP32 above any splash line. Confirm WiFi reaches the door (same check as the food-temp build — a dead spot means relocating a mesh node).

Phased build plan¶

1. Step 0 — identify the tag. Don't buy a reader until you know frequency + encoding.
2. Bench the reader. Wire RDM6300 → ESP32, flash the base config, confirm it reads each collar tag in the logs; record UIDs.
3. Build & tune the coil for reliable reads across the whole aperture at speed.
4. Add the direction gate (two IR beams) and confirm beam order tracks direction.
5. Pair in HA, add the per-cat helpers + passage automations; verify in/out status flips correctly.
6. Mount at the door, weatherproof, confirm WiFi, live-test with the cats.
7. Tune antenna position and debounce until misses/double-reads are rare; then add the night/curfew automations and the dashboard card.

Risks & open questions¶

• Tag frequency/encoding (Step 0) — the single biggest unknown. PetLibro saying it "does not support microchips" implies a proprietary 125 kHz tag; verify before buying a reader.
• Read reliability at speed — LF range is short; a fast or off-center cat can be missed. Antenna tuning and coil placement are where the time goes. The beam gate degrades gracefully (you still get a direction event even on an RFID miss; you just won't know which cat that once).
• Two cats at once — rare through a small flap, but the logic should handle near-simultaneous reads (per-tag binary_sensors already separate them).
• Tag wear / loss — collars use a 6.6 lb snap-release, so a tag can pop off outdoors. A long "out" with no return is worth an alert anyway.
• Proprietary lock-in — if the PetLibro tag turns out to be an unreadable custom protocol, fallback options: add a cheap standard 125 kHz EM4100 tag to each collar alongside the PetLibro one, or switch to implantable-microchip reading (134.2 kHz FDX-B) if the cats are chipped.

Future expansion¶

• Selective entry — drive a servo/latch so only known tags unlock the flap (DIY SureFlap).
• Per-cat analytics — time-outdoors trends in Grafana, like the energy/circuit panels.
• Litter / feeding correlation — combine cat-door passages with the PetLibro feeder/fountain data for a fuller activity picture.
• Multi-door — replicate the rig at a second door; HA already tracks per-cat state centrally.

Related pages: Cameras · Notifications & Alerts · Automations Reference · Food Temp Sensor Build · Hardware Inventory