This project presents a modular remote control and monitoring system using two ESP-01 (ESP8266/ESP8285) Wi-Fi modules. Node 1 functions as the temperature monitoring and relay control node, equipped with a DS18B20 temperature sensor connected to GPIO2 and one relay connected to GPIO0. Node 2 functions as a dedicated relay control node, operating two relays through GPIO2 and GPIO0. Together, the two nodes control a total of three relays while monitoring the ambient temperature through a single dashboard.

A significant portion of this project focused on configuring the software environment rather than assembling the hardware. Home Assistant and ESPHome were installed in Docker containers running on a Windows computer. This setup required resolving several networking and communication issues to ensure reliable connectivity between both ESP-01 nodes and Home Assistant. The complete configuration and troubleshooting process is documented in this project to assist others who wish to build a similar system.

After the system was successfully configured, Home Assistant detected both Node 1 and Node 2, displaying all three relays as controllable switches and the temperature as a real-time sensor reading on a single dashboard. A temperature protection automation was also implemented: whenever the temperature exceeds 35°C, all three relays automatically turn off to protect the connected devices. The relays remain off until they are manually reactivated by the user through the dashboard.

This remote control and monitoring system is suited for any scenario where devices need to be controlled remotely while also being monitored for safety conditions. Key use cases include:

• Home Automation — Allows users to remotely control lights, fans, and other electrical appliances through the Home Assistant dashboard without replacing existing devices with expensive smart appliances.
• Temperature-Based Protection — Automatically turns off all connected relays when temperature exceeds 35°C, protecting equipment from heat damage without requiring user intervention.
• Learning and Development — Serves as a practical platform for learning IoT technologies, including ESPHome, Home Assistant, and Docker, while demonstrating how they work together in a home automation system.
• Easy to Use — The Home Assistant dashboard provides a user-friendly interface that allows users to monitor temperature, control relays, create automations, and expand the system without requiring programming knowledge.

Gather everything below before you start. This is your checklist — names, models, and versions only.

Here is what each component does and why it is part of this project.

The ESP-01 is one of the smallest and most affordable Wi-Fi modules based on the ESP8266 microcontroller. Despite its compact size, it provides only two usable General-Purpose Input/Output (GPIO) pins: GPIO0 and GPIO2. In this project, two ESP-01 modules are assigned different roles to maximize their limited I/O capabilities. Node 1 uses GPIO2 to interface with the DS18B20 temperature sensor and GPIO0 to control Relay 2. Meanwhile, Node 2 uses GPIO2 and GPIO0 to control Relay 3 and Relay 4, respectively. This modular design allows each node to perform a dedicated function, simplifies system management, and provides flexibility for future expansion by enabling additional nodes to be integrated as needed.

The DS18B20 is a digital temperature sensor that communicates using the One-Wire protocol, allowing data transmission over a single signal wire. In this project, the sensor is connected to Node 1 through GPIO2 and requires a 4.7 kΩ pull-up resistor between the data line and the 3.3 V supply for proper operation. Without this resistor, the sensor will not communicate correctly with the ESP-01, regardless of the ESPHome YAML configuration. The DS18B20 measures the ambient temperature and transmits the readings to Home Assistant through ESPHome at 30-second intervals. These real-time temperature readings are used to trigger a Home Assistant automation that automatically turns off all three relays whenever the temperature exceeds 35°C, providing protection for the connected devices.

The project uses a total of three relay channels across both nodes. Node 1 controls one relay through GPIO0, and Node 2 controls two relays through GPIO2 and GPIO0. All relay channels use SRD-05VDC-SL-C modules which are active-LOW, meaning the relay turns on when the GPIO pin outputs a LOW signal instead of a HIGH signal. This behavior is configured in the ESPHome firmware using the inverted: true switch option, ensuring that the ON/OFF state displayed in Home Assistant matches the physical relay state correctly.

ESPHome is a firmware framework used to program ESP8266 and ESP32 devices, such as the ESP-01. It uses YAML configuration files to generate the firmware and allows the devices to communicate with Home Assistant through the ESPHome API. In this project, ESPHome is also used to flash the firmware to the ESP-01 modules and perform wireless (OTA) updates. Since the project uses Home Assistant Container instead of Home Assistant OS, ESPHome runs in its own Docker container.

Home Assistant serves as the central control system of the project. It connects to each ESP-01 node through the ESPHome integration and displays each relay as a switch and the temperature as a live sensor reading on the dashboard. Users can easily monitor and control all relays through a web browser, create automations, and manage the system without needing to write any code.

Docker is used to run Home Assistant and ESPHome in separate containers, allowing both applications to run without being installed directly on Windows. Since Docker cannot run natively on Windows, it uses WSL2 (Windows Subsystem for Linux), which provides a Linux environment for running Docker. In this project, Docker Engine was installed directly inside the WSL2 Ubuntu environment instead of using Docker Desktop. This setup provides a lightweight and flexible environment for running the home automation system.

Since the ESP-01 has no onboard USB port, this adapter bridges its serial TX/RX pins to a USB port on the PC, presenting itself as a COM port. It is required for the very first firmware flash of each node, since a brand-new device cannot yet be reached wirelessly (OTA) until it already has working Wi-Fi firmware on it.

Wire the components to the board using the tables below.

Assembly Instructions

Assembly Instructions

Assembly Instructions

This is the core of the project. Follow these steps in order — several of them exist specifically because of problems encountered while building this exact system, and skipping them will reproduce those same problems.

1. Open PowerShell.
2. Run:

wsl --install

3. Restart the PC when prompted. Ubuntu installs automatically as the default distribution.

1. Ubuntu opens automatically after reboot, or launch it from the Start menu.
2. Create a Unix username (lowercase, no spaces) and a password when prompted.

Docker Desktop was the original plan, but installation stalled due to insufficient free space on the Windows drive. Rather than fight that constraint, Docker Engine was installed directly inside the Ubuntu/WSL2 environment — a lighter-weight path with no separate Windows application at all.

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo service docker start

1. Create the project structure:

mkdir -p ~/smart-home/homeassistant
mkdir -p ~/smart-home/esphome

2. Create the Compose file directly via terminal:

cat > ~/smart-home/docker-compose.yml << 'EOF'
services:
  homeassistant:
    container_name: homeassistant
    image: ghcr.io/home-assistant/home-assistant:stable
    restart: unless-stopped
    privileged: true
    network_mode: host
    volumes:
      - ./homeassistant:/config
    environment:
      - TZ=Asia/Manila

  esphome:
    container_name: esphome
    image: ghcr.io/esphome/esphome
    restart: unless-stopped
    network_mode: host
    volumes:
      - ./esphome:/config
EOF

3. Start the stack:

cd ~/smart-home
sudo docker compose up -d
sudo docker ps

Confirm both containers show Up, then open:

• Home Assistant — http://localhost:8123
• ESPHome Dashboard — http://localhost:6052

This is the single most consequential issue in the whole project. A normal ping from Windows PowerShell to an ESP-01's IP address can succeed perfectly, while Home Assistant still reports the device as offline. The reason: WSL2's default networking mode isolates the Linux environment — and therefore every Docker container inside it — from the host's real local network.

This is confirmed directly by testing from inside the container itself:

sudo docker exec -it homeassistant ping -c 4 <esp-node-ip>

100% packet loss here confirms the issue. The fix is to switch WSL2 to mirrored networking mode:

wsl --shutdown
notepad "$env:USERPROFILE\.wslconfig"

Add the following content to that file:

[wsl2]
networkingMode=mirrored
vmIdleTimeout=-1

Save, then restart WSL and the stack:

wsl
sudo service docker start
cd ~/smart-home
sudo docker compose up -d

Without a fixed IP, DHCP can hand an ESP-01 a different address every time it reconnects, and Home Assistant's reliance on mDNS to rediscover it proved unreliable inside this Docker/WSL2 setup. The fix is a hardcoded static IP per device (shown in full in Section 06). When running more than one node, each device must have a unique static_ip and a unique name — reusing either causes the two physical devices to intermittently fight over the same network identity.

To find your current gateway and pick a safe static IP, run the following commands in WSL:

ip route       # look for "default via" — that is your gateway
arp -a         # shows all devices currently on the network — pick an unused address

1. Wire the ESP-01 to the USB-to-TTL adapter per Section 04, with GPIO0 pulled to GND.
2. Open the ESPHome dashboard at http://localhost:6052 and create a new device.
3. Paste in the YAML configuration from Section 06 for that node.
4. Click Install → Plug into this computer (or use web.esphome.io directly with the "Manual download" firmware file).
5. After flashing completes, disconnect GPIO0 from GND and power-cycle the board.

1. In Home Assistant, go to Settings > Devices & Services > Add Integration > ESPHome.
2. Enter the node's static IP as the Host, leave Port at 6053.
3. When prompted, paste the device's api.encryption.key from its YAML.

Docker Engine installed this way does not auto-start with Windows the way Docker Desktop does. Both Docker and WSL2 idle-shutdown issues need to be solved together.

1. Create the startup script:

cat > ~/start-smarthome.sh << 'EOF'
#!/bin/bash
sudo service docker start
sleep 5
cd ~/smart-home
sudo docker compose up -d
EOF
chmod +x ~/start-smarthome.sh

2. Allow this script to run without an interactive password prompt:

sudo visudo

Add this line at the bottom (replace YOUR_USERNAME):

YOUR_USERNAME ALL=(ALL) NOPASSWD: /usr/sbin/service docker start, /usr/bin/docker compose up -d

3. Register a Windows scheduled task (run from an Administrator PowerShell window):

schtasks /create /tn "StartSmartHome" /tr "wsl.exe -d Ubuntu /home/YOUR_USERNAME/start-smarthome.sh" /sc onlogon /rl highest

Once both nodes are online in Home Assistant, create an automation that automatically turns off all three relays when the temperature sensor on Node 1 exceeds 35°C. The relays stay off until the user manually turns them back on.

1. Go to Settings → Automations & Scenes → Create Automation
2. Click Start with an empty automation
3. Click the three-dot menu (⋮) in the top right → Edit in YAML
4. Replace everything with the following:

alias: Turn off relays when temperature exceeds 35°C
description: >
  Automatically turns off Relay 2, Relay 3, and Relay 4 when the
  temperature sensor reads above 35°C. The user must manually
  turn the relays back on.
triggers:
  - entity_id: sensor.control_system_node_1_temperature
    above: 35
    trigger: numeric_state
actions:
  - action: switch.turn_off
    target:
      entity_id: switch.control_system_node_1_relay_2
  - action: switch.turn_off
    target:
      entity_id: switch.control_system_node_2_relay_3
  - action: switch.turn_off
    target:
      entity_id: switch.control_system_node_2_relay_4
mode: single

5. Click Save and confirm the automation is enabled (toggle is blue) in the automations list.

Each node uses its own ESPHome YAML configuration. Replace the placeholder Wi-Fi credentials, encryption key, and network values for your own setup before flashing.

Here is what each part of the configuration does. Read this after flashing to understand how the system actually works.

After setup, verify each of the following to confirm the system is working correctly end-to-end.

Run the following from inside Ubuntu after both containers are up:

sudo docker exec -it homeassistant ping -c 4 10.0.0.51
sudo docker exec -it homeassistant ping -c 4 10.0.0.52

Both should report 0% packet loss. This is the single most reliable indicator that the whole network chain is correctly configured.

Open each device's logs in the ESPHome dashboard. A correctly connected node shows lines similar to:

[I][wifi:1575]: Connected
[C][wifi:1237]:   IP Address: 10.0.0.51
[D][api.connection]: Home Assistant ... connected

In Home Assistant, go to the dashboard and locate the Temperature entity from Node 1. It should display a live reading in °C rather than "Unknown". If it shows Unknown, check that the 4.7kΩ pull-up resistor is correctly wired between the DS18B20 data pin and 3.3V.

Under Settings > Devices & Services, both nodes should appear with their relay switch entities listed and toggleable. Toggling a switch in the UI should produce an audible relay click within roughly one second.

To test the temperature protection automation:

1. Manually turn on all three relays from the Home Assistant dashboard.
2. Hold the DS18B20 sensor between your fingers for about one minute to warm it above 35°C.
3. Watch the dashboard — all three relays should automatically turn off within one second of the temperature exceeding 35°C.
4. Release the sensor and let it cool. Confirm the relays stay off even after the temperature drops below 35°C.
5. Manually turn the relays back on from the dashboard to confirm user control is working correctly.

Fully restart the Windows PC, log back in, wait roughly 30–40 seconds without opening any terminal, then load http://localhost:8123 directly. If the automation from Section 05, Step 9 is correctly configured, the dashboard loads with no manual intervention.

The completed system demonstrates that a reliable, self-hosted remote control and monitoring system can be built using two ESP-01 modules, ESPHome, and Home Assistant running on a Windows laptop with Docker Engine and WSL2, eliminating the need for dedicated server hardware.

A key finding of this project is that the primary challenges were related to software configuration rather than hardware. Proper networking setup, including static IP addresses and WSL2 mirrored networking, was essential to ensure stable communication between Home Assistant and the ESP-01 nodes.

The integration of the DS18B20 temperature sensor and Home Assistant automation added an important safety feature by automatically turning off all three relays whenever the temperature exceeds 35°C, while still allowing manual reactivation through the dashboard.

Overall, the project provides a reliable, low-cost, and expandable IoT solution that demonstrates the practical integration of ESPHome, Home Assistant, Docker, and WSL2 for remote monitoring and control.

To further improve the system, the following enhancements are recommended:

• Use a dedicated Wi-Fi router instead of a mobile hotspot to eliminate AP isolation issues and prevent subnet changes that require reconfiguration of static IPs.
  
• Expand the system by adding more ESP-01 nodes to control additional relays. The modular design makes it easy to increase the number of controllable devices without modifying the existing setup.

• Espressif Systems — ESP8266 Technical Reference Manual
• ESPHome — Official Documentation
• ESPHome — Dallas Temperature Component Documentation
• Home Assistant — Official Documentation (Container Installation)
• Home Assistant — Automations Documentation
• Microsoft — WSL2 Networking Documentation (Mirrored Mode)
• Docker — Official Engine Installation Documentation (get.docker.com)
• Docker — Compose File Reference
• FTDI — FT232R USB UART IC Datasheet

• Joshua T. Colendres
• McRaven B. Batapa