Operation Smart Home: A Father-Son Mission Brief

You know what the world has enough of? People who talk about what they're going to do someday. Dreamers sitting on their hands, waiting for the perfect moment, the perfect setup, the perfect whatever. Meanwhile life keeps ticking.

"I felt once more how simple and frugal a thing is happiness: a glass of wine, a roast chestnut, a wretched little brazier, the sound of the sea. Nothing else." — Nikos Kazantzakis, Zorba the Greek

Zorba didn't wait. Zorba danced. Zorba failed spectacularly and laughed about it. When his grand mining operation collapsed - literally collapsed - he grabbed a bottle of wine and started dancing on the beach. It's better to fail like Zorba than to sit on your hands.

So today, my son and I execute. The plan is drawn. The hardware is prepped. Most of it has been tested individually - the automations work, the sensors detect, the code compiles. Now we see if it all plays together. Will something go sideways? Probably. Are we ready for challenges? Absolutely. That's the fun part.

Without a plan, there is no path forward. Just people talking to hear themselves speak. Just dreams. This isn't a dream - this is an execution brief.

The Mission

By the time we're grilling dinner tonight, this house will:

• Turn on lights in the room you're entering, fade them behind you as you leave
• Lock every door when the bed senses we've gone to sleep
• Close the garage automatically when we forget (again)
• Adjust the climate based on which rooms are actually occupied
• Generate WiFi noise so nobody outside can use the same sensing tech against us

And Amazon won't know a damn thing about it. Everything runs local. No cloud. No subscriptions. No data harvesting.

The Arsenal (Already Staged)

The Brain: Raspberry Pi 5 - READY

This thing has been sitting on my desk for two weeks, fully configured, waiting for today. Pi 5 is overkill for basic home automation. I like overkill. It's running Raspberry Pi OS Lite, Docker is installed, Portainer is humming. All I have to do is plug it in where it's going to live.

I went with the Argon ONE V3 M.2 NVME PCIE Case bundle. Already assembled:

• M.2 SSD with OS flashed (no SD card failures for us)
• Docker + Portainer installed and tested
• Home Assistant container ready to deploy
• Static IP assigned on the network

The Sensors: ESP32 Boards - FLASHED AND TESTED

These little ESP32 boards have been the fun part. My son and I spent last weekend flashing them and watching the WiFi signal data roll in. They work. Confirmed.

1. WiFi Sensing unit - Detects movement by measuring WiFi signal disruption. Tested it by walking around the living room - picks up motion through walls, about 15-20 feet range.
2. WiFi Fog unit - Generates noise to blind any external WiFi sensing. Running in isolation, creating beautiful chaos in the signal space.

Today we integrate them into Home Assistant and see if the automations fire correctly. The code works in testing. The question is: does it work when it's all connected?

(If you want the backstory on why this matters, read my articles on WiFi sensing and WiFi countermeasures.)

The Existing Infrastructure - ALREADY IN PLACE

We're not starting from scratch. The house already has smart stuff - it's just been running on separate apps like a bunch of disconnected islands. Today we unify the kingdom:

• Philips Hue bulbs - Already installed throughout. Currently controlled by the Hue app. Today: Home Assistant takes over.
• Ecobee thermostat - Already knows which rooms are occupied via its sensors. Today: we integrate that data.
• Eight Sleep bed - Already tracking when I'm asleep. Today: it triggers the lockdown automation.
• Kwikset locks (Z-Wave) - Already on the doors. Today: they learn to lock themselves.
• MyQ garage - Already installed. Today: no more driving back home because I forgot to close it.

The point: You might already have more smart home gear than you realize. It's just not talking to each other yet.

Phase 1: Infrastructure (DONE)

This is last weekend's work. If you're following along later, here's what we did. If you read my Docker article, you know why we containerized everything.

# Docker + Portainer - Already running
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

docker volume create portainer_data
docker run -d -p 9000:9000 --name portainer \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer-ce

Portainer is live at http://raspberrypi.local:9000. Beautiful GUI for container management. Checked.

Phase 2: Home Assistant (TODAY'S FIRST TASK)

The docker-compose file is written. The config directory is staged. Today we spin it up for real and start connecting devices.

# docker-compose.yml - ready to deploy
version: '3'
services:
  homeassistant:
    container_name: homeassistant
    image: ghcr.io/home-assistant/home-assistant:stable
    volumes:
      - /home/pi/homeassistant:/config
      - /etc/localtime:/etc/localtime:ro
    restart: unless-stopped
    privileged: true
    network_mode: host

The plan: Run docker-compose up -d, hit the setup wizard, and connect these integrations one by one:

• Philips Hue - Should auto-discover on the network
• Ecobee - OAuth flow, need to have the app handy
• Eight Sleep - API integration, credentials ready
• Z-Wave - This one might get spicy, locks can be finicky
• MyQ - Straightforward, done this before
• ESPHome - For the ESP32 devices we flashed last weekend

Expected challenge: Z-Wave. Locks always have attitude. We'll see.

Phase 3: WiFi Sensing Integration (TODAY'S FUN PART)

The Sensing Unit - READY TO CONNECT

Last weekend my son watched the serial monitor as this thing detected me walking through the living room. His exact words: "Dad, this is creepy and awesome."

The ESP32 is already flashed with ESPHome. It's already detecting motion via WiFi CSI (Channel State Information). Today we plug it into Home Assistant and give it a name: binary_sensor.living_room_occupied

The test: Walk into the living room. Does Home Assistant see it? If yes, we're in business.

The Fog Unit - PRIVACY LAYER READY

The second ESP32 runs the noise generator from my countermeasures article. It's been running on my bench for a week, generating beautiful chaos in the WiFi spectrum.

Yes, we're using WiFi sensing for our own automation while simultaneously protecting against others doing the same to us. It's not hypocrisy. It's operational security. And my son thinks it's the coolest thing ever.

Future Expansion: 3+3

Today's goal is proving the concept with one sensor and one fog device. Once we're confident:

• 3 Sensing devices: Living room, kitchen, bedroom
• 3 Fog devices: Distributed throughout for complete coverage

That's about $50 in ESP32 boards for a whole-house upgrade. But first - let's make sure today works.

Phase 4: The Automations (THE WHOLE POINT)

This is what it's all been building to. These YAML files are written, tested in my head a hundred times, and ready to paste. Will they work first try? Let's find out.

Automation 1: Follow-Me Lighting (THE SHOWSTOPPER)

The vision: Walk into a room, lights rise to greet you. Leave, and they fade behind you like a respectful butler. Tony Stark's house. That's the goal.

The nuance: If you manually turned on a light, the system leaves it alone. Your choice is honored. We track this with input_boolean helpers. Because nothing's worse than automation that fights you.

# configuration.yaml additions
input_text:
  last_occupied_room:
    name: "Last Occupied Room"
    initial: "none"

input_boolean:
  living_room_auto_triggered:
    name: "Living Room Auto Triggered"
  kitchen_auto_triggered:
    name: "Kitchen Auto Triggered"
  bedroom_auto_triggered:
    name: "Bedroom Auto Triggered"

Now the automation:

# automations.yaml
- alias: "Follow Me - Living Room Entry"
  trigger:
    - platform: state
      entity_id: binary_sensor.living_room_occupied
      to: "on"
  condition:
    - condition: state
      entity_id: light.living_room
      state: "off"
  action:
    # Dim the previous room if it was auto-triggered
    - choose:
        - conditions:
            - condition: template
              value_template: "{{ states('input_text.last_occupied_room') == 'kitchen' }}"
            - condition: state
              entity_id: input_boolean.kitchen_auto_triggered
              state: "on"
          sequence:
            - service: light.turn_on
              target:
                entity_id: light.kitchen
              data:
                brightness_pct: 20
                transition: 3
    # Turn on current room
    - service: light.turn_on
      target:
        entity_id: light.living_room
      data:
        brightness_pct: 100
    - service: input_boolean.turn_on
      target:
        entity_id: input_boolean.living_room_auto_triggered
    - service: input_text.set_value
      target:
        entity_id: input_text.last_occupied_room
      data:
        value: "living_room"

- alias: "Follow Me - Living Room Vacancy"
  trigger:
    - platform: state
      entity_id: binary_sensor.living_room_occupied
      to: "off"
      for:
        minutes: 2
  condition:
    - condition: state
      entity_id: input_boolean.living_room_auto_triggered
      state: "on"
  action:
    - service: light.turn_off
      target:
        entity_id: light.living_room
      data:
        transition: 5
    - service: input_boolean.turn_off
      target:
        entity_id: input_boolean.living_room_auto_triggered

The test: Once this is deployed, my son and I are going to walk through the house and see if it follows us. If it works, we're going to feel like we're in a movie. If it doesn't, we'll debug it over pizza.

Automation 2: Bedtime Lockdown (THE PEACE OF MIND)

The scenario: It's 10 PM. I climb into bed. Five minutes later, my Eight Sleep confirms I'm actually sleeping (not just lying there scrolling). The house responds: every door locks, the garage closes if I forgot (again), thermostat drops to sleep mode, and lights that were auto-triggered fade out.

- alias: "Bedtime - Eight Sleep Triggered Lockdown"
  trigger:
    - platform: state
      entity_id: binary_sensor.eight_sleep_bed_presence
      to: "on"
      for:
        minutes: 5
  condition:
    - condition: time
      after: "21:00:00"
      before: "06:00:00"
  action:
    # Lock all doors
    - service: lock.lock
      target:
        entity_id:
          - lock.front_door
          - lock.back_door
    # Close garage if open
    - service: cover.close_cover
      target:
        entity_id: cover.garage_door
    # Set Ecobee to sleep mode
    - service: climate.set_preset_mode
      target:
        entity_id: climate.ecobee
      data:
        preset_mode: "Sleep"
    # Turn off auto-triggered lights
    - service: light.turn_off
      target:
        entity_id:
          - light.living_room
          - light.kitchen
      data:
        transition: 5

Don't have Eight Sleep? Substitute a time-based trigger (10:30 PM) or phone charging detection. The logic is the same.

Automation 3: Garage Auto-Close (THE MARRIAGE SAVER)

The problem: "Did you close the garage?" - a question asked 3x per week in this household. No more. After 10 minutes open, it closes itself and texts me.

- alias: "Garage - Auto Close After 10 Minutes"
  trigger:
    - platform: state
      entity_id: cover.garage_door
      to: "open"
      for:
        minutes: 10
  action:
    - service: cover.close_cover
      target:
        entity_id: cover.garage_door
    - service: notify.mobile_app_your_phone
      data:
        title: "Garage Secured"
        message: "Garage was open for 10 minutes. Auto-closed."
        data:
          tag: "garage-closed"

Automation 4: Smart Climate (THE ENERGY SAVER)

The logic: Why heat an empty house? When our WiFi sensors say nobody's been home for 30 minutes, Ecobee goes to Away mode. When someone walks in, it wakes back up.

- alias: "Ecobee - Away When House Empty"
  trigger:
    - platform: state
      entity_id: binary_sensor.home_occupied
      to: "off"
      for:
        minutes: 30
  action:
    - service: climate.set_preset_mode
      target:
        entity_id: climate.ecobee
      data:
        preset_mode: "Away"

- alias: "Ecobee - Home When Occupied"
  trigger:
    - platform: state
      entity_id: binary_sensor.home_occupied
      to: "on"
  condition:
    - condition: state
      entity_id: climate.ecobee
      attribute: preset_mode
      state: "Away"
  action:
    - service: climate.set_preset_mode
      target:
        entity_id: climate.ecobee
      data:
        preset_mode: "Home"

template:
  - binary_sensor:
      - name: "Home Occupied"
        state: >
          {{ is_state('binary_sensor.living_room_occupied', 'on')
             or is_state('binary_sensor.kitchen_occupied', 'on')
             or is_state('binary_sensor.bedroom_occupied', 'on') }}

What Could Go Wrong? (The Fun Part)

Here's the thing: something WILL go wrong today. That's not pessimism - that's reality. And that's fine. That's the whole point.

Likely candidates for today's adventure:

• Z-Wave locks - These things have attitude. Pairing might take multiple attempts.
• WiFi sensor calibration - Works on the bench, but what about when it's in position?
• Automation edge cases - What happens if someone walks through a room in 2 seconds?
• The "it worked yesterday" problem - Technology's favorite joke.

But that's why we're doing this together. Father and son, troubleshooting, learning, probably arguing about why the YAML isn't parsing. This is how you actually learn - by building something real and watching it break and fixing it.

Zorba's mine collapsed. His response? Dance on the beach. Whatever breaks today, we'll figure it out. And if we can't, we'll have a great story for dinner.

The Philosophy

Here's what separates the doers from the dreamers:

Dreamers research for months. They read every article. They wait for the "right" hardware. They optimize their plan until it's perfect. They never start.

Doers write down a plan, gather what they need, and execute. They expect challenges. They adjust on the fly. They fail forward.

Without a plan, there is no path forward - only people talking to hear themselves speak. But a plan without execution is just a dream with extra steps.

What's Next (After Today Works)

Assuming we succeed - and we will, eventually, even if it takes longer than expected:

• Full 3+3 ESP32 deployment - Sensing in every main room, fog coverage throughout
• Wall-mounted tablet dashboard - Always-on control panel in the hallway
• Local voice control - Wyoming/Piper for voice commands that don't leave your house
• Water leak sensors - Under every sink and by the water heater

But first: today. First: execution. First: proving that all this planning actually works.

"Life is what happens to you while you're busy making other plans." - John Lennon

Wrong. Life is what happens when you stop planning and start doing. See you on the other side.

Time to go build something.