Published July 27, 2026 © GPL3+

Building a Wired Smart Workshop with ESPHome and Ethernet

A wired automation system using ESPHome, Home Assistant and DFRobot sensors for reliable lighting and CO2-based ventilation.

IntermediateFull instructions provided3 hours74

Building a Wired Smart Workshop with ESPHome and Ethernet

Things used in this project

Hardware components

DFRobot Fermion: C4002 mmWave Human Presence Sensor - Static & Motion Detection for Home Assistant (10m)

DFRobot Gravity STCC4 CO2 sensor

WT32-ETH01

AC-DC 5W 5V 1A

DT-R008

HDR-30-12

Software apps and online services

Home Assistant

Hand tools and fabrication machines

3D Printer (generic)

Soldering iron (generic)

Solder Wire, Lead Free

Multitool, Screwdriver

Story

Video version of the article:

Introduction

When I renovated my workshop, I decided to prepare for future automation instead of relying on Wi-Fi devices. Every wall switch and outlet location received an additional Ethernet cable, giving me a reliable communication channel for sensors, switches, and controllers.

This approach required more effort during installation, but it came with several important advantages: stable communication, immunity to Wi-Fi congestion, Power over Ethernet (PoE) support for compatible devices, and significantly lower power consumption for distributed sensors.

The goal of this project was to automate two everyday tasks:

Turn the workshop lights on automatically when someone enters and switch everything off after the room has been empty for 15 minutes.
Control the ventilation system based on both occupancy and indoor CO2 concentration, ensuring fresh air without running the fan unnecessarily.

To accomplish this, I used two recently released DFRobot sensors:

C4002 mmWave Presence Sensor for reliable human presence detection.
STCC4 CO2 Sensor for monitoring air quality and controlling the ventilation system.

1 / 2

Why Wired Instead of Wi-Fi?

Wireless smart home devices are easy to install, but they also introduce limitations that become noticeable as the system grows. Every battery-powered sensor needs maintenance, Wi-Fi networks become more crowded over time, and reliability depends on radio coverage.

Since the walls of my workshop were already open during renovation, adding Ethernet cables cost very little compared to the overall project. That small decision made it possible to build an automation system that behaves much more like industrial control equipment than a typical consumer smart home.

The benefits include:

Reliable wired communication
No dependence on Wi-Fi coverage
Lower power consumption for remote devices
PoE support where applicable
Easy future expansion without opening the walls again

Of course, there is one obvious disadvantage - you have to plan the wiring before finishing the room.

System Overview

The automation system consists of two Ethernet-connected ESPHome devices.

The first device is a DT-R008 Ethernet relay controller, which acts as the central PLC. It is responsible for switching the workshop lighting, reading the wall switches, controlling the ventilation fan, and communicating with Home Assistant over Ethernet.

The second device is built around a WT32-ETH01 module and serves as the environmental monitoring node. It collects data from the DFRobot sensors and reports it to Home Assistant using ESPHome.

This separation keeps the control logic modular. The relay controller focuses on switching loads, while the sensor node handles environmental measurements and occupancy detection. Since both devices are connected through Ethernet, the system remains completely independent of Wi-Fi.

The current implementation automates two tasks:

Lighting - the C4002 mmWave sensor detects presence and turns the lights on automatically. If the workshop remains empty for 15 minutes, the lights and other selected devices are switched off.
Ventilation - every 10 minutes Home Assistant checks the CO2 concentration reported by the STCC4 sensor. If the air quality drops below the configured threshold while someone is present in the workshop, the ventilation fan is turned on automatically.

The actual automation logic runs in Home Assistant, while both ESPHome devices expose their sensors and outputs as standard entities.

Hardware

The project intentionally uses mostly off-the-shelf components. Aside from the custom 3D-printed sensor enclosure, everything can be purchased from common electronics suppliers.

DT-R008 Ethernet Relay Controller - Main PLC responsible for switching loads, reading inputs, and communicating with Home Assistant.
WT32-ETH01 - Ethernet-enabled ESP32 module used as the dedicated sensor node.
DFRobot C4002 - mmWave presence sensor for occupancy detection.
DFRobot STCC4 - CO2 sensor used for air quality monitoring and ventilation control.
MeanWell HDR-30-12 - 12V DIN-rail power supply for the relay controller and relays.
5V AC-DC Power Supply - Powers the WT32-ETH01 sensor node.
DIN-Rail Relay - Controls the workshop lighting and provides manual override with state feedback.
Ethernet (UTP) Cabling - Provides reliable wired communication between all ESPHome devices.

Why a PLC Instead of Individual Smart Relays?

One of the goals of this project was reliability.

Instead of installing a separate Wi-Fi relay behind every wall switch, all wiring terminates inside a single control panel. This approach makes maintenance significantly easier and allows the entire electrical system to be managed from one location.

Another important advantage is that the wall switches continue to operate even if Home Assistant or the network becomes unavailable.

Relay #8 is wired together with the manual wall switch as a two-way switch. This circuit drives a separate DIN-rail relay that actually powers the lighting circuit. Additional auxiliary contacts on the DIN relay provide feedback to the DT-R008, allowing Home Assistant to know the true state of the lights regardless of whether they were switched manually or automatically.

For the multi-speed ventilation fan, relays 1-3 replace the original mechanical selector switch. They are connected in series so that only one fan speed can be energized at a time, preventing accidental short circuits caused by software or configuration errors.

Building the Control Panel

To accommodate all the required components, I cut a mounting plate to the desired size and installed a DIN rail, wire clips, and a wiring duct for cable management.

1 / 5

Wiring

The actual wiring process is repetitive rather than difficult. Each wire must be measured, cut, stripped, routed through the wiring duct, and terminated.

Although time-consuming, careful cable routing makes troubleshooting much easier later.

The complete wiring schematic is attached to this project, so I won't repeat every connection here. Instead, I'd like to explain several design decisions that make the system reliable.

Lighting Control with Manual Override

One of my requirements was that the workshop lights must continue to work even if Home Assistant, ESPHome, or the network becomes unavailable.

To achieve this, Relay 8 and the wall switch are wired together as a two-way switch. Instead of switching the lighting circuit directly, they control a separate DIN-rail relay, which supplies power to the lights.

The auxiliary contacts of the DIN relay are connected back to the DT-R008 digital inputs, providing feedback about the actual state of the lighting circuit.

As a result, Home Assistant always knows whether the lights are ON or OFF, regardless of whether they were switched manually or automatically.

Safe Fan Speed Selection

The workshop ventilation fan supports multiple speed settings.

Instead of replacing the original selector switch with a single relay, I dedicated three relays to fan speed control.

These relays are connected in series to mimic the original rotary switch. This wiring guarantees that only one speed can be energized at a time, preventing accidental activation of multiple windings due to software bugs or configuration errors.

This hardware safeguard makes the system significantly more robust than relying solely on software logic.

Why Ethernet?

Many DIY automation projects rely entirely on Wi-Fi, but I deliberately avoided it for the core infrastructure.

Both ESPHome devices communicate exclusively over Ethernet, providing:

stable communication without signal drops,
deterministic latency,
no dependence on Wi-Fi coverage,
lower power consumption on the microcontrollers,
room for future PoE-powered devices.

Since the Ethernet cables were installed during the workshop renovation, adding new devices later only requires connecting them to the existing network.

Flashing the DT-R008

The DT-R008 ships with factory firmware that already supports MQTT and Home Assistant integration. For many users, this firmware will be perfectly adequate and requires no modifications.

However, I wanted to integrate the relay controller into my existing ESPHome ecosystem, so I decided to replace the factory firmware.

If you plan to do the same, make sure to order the developer version of the DT-R008. The standard version ships with the ESP32 protected against reflashing, while the developer version allows custom firmware to be uploaded without hardware modifications.

For ESPHome support, I used the excellent dtr0xx_io component by kecajtop, which provides native integration with the relay board.

Debug Port Pinout:

1 - GND

2 - IO3 (U0RXD/RS485 RX)

3 - IO1 (U0TXD/RS485_TX)

4 - NRST

5 - IO0 (RMII_RST/PWR)

6 - 3.3V

7 - IO4 (CAN_RX)

9 - IO5 (CAN_TX)

Sensor Node

The workshop uses a dedicated Ethernet sensor node based on the WT32-ETH01. Instead of connecting every sensor directly to the relay controller, this separate node handles all environmental monitoring and publishes the measurements to Home Assistant through ESPHome.

The node combines two DFRobot sensors:

C4002 mmWave Presence Sensor for occupancy detection.
STCC4 CO2 Sensor for indoor air quality monitoring.

Both sensors communicate using different interfaces. The C4002 uses UART, while the STCC4 communicates over I²C, making them a good fit for the WT32-ETH01.

1 / 3

To simplify installation, I designed and 3D-printed a new enclosure that houses both sensors together with the WT32-ETH01 module. The STL files are attached to this project.

STCC4 CO2 Sensor

The STCC4 is a low-power CO2 sensor based on thermal conductivity measurement. While it is not a laboratory-grade instrument, it provides more than enough accuracy for demand-controlled ventilation.

The sensor measures CO2 concentrations from 500 ppm to 5000 ppm with a typical accuracy of ±100 ppm. In practice, this is sufficient to determine when fresh air is needed inside the workshop.

Another useful feature is the integrated temperature and humidity sensor used for internal compensation. An external sensor can also be connected if higher temperature accuracy is required.

During testing, the CO2 readings proved to be stable and responsive enough for automation purposes.

ESPHome Support

At the time of building this project, the STCC4 was not yet included in the official ESPHome release.

Fortunately, I found an open pull request by will-tm, which already contained a working implementation of the component.

Rather than waiting for the pull request to be merged, I used that implementation directly in my project.

The corresponding repository is linked in the Credits section of this project.

C4002 mmWave Presence Sensor

Presence detection is one of the most important parts of the entire automation system.

The C4002 offers a detection range of up to 11 meters and allows configuring separate sensitivity thresholds for each distance segment. It also includes an ambient light sensor, enabling additional automation based on illumination if required.

Unfortunately, the software support initially wasn't as polished as the hardware.

Improving the ESPHome Component

DFRobot community provides an external ESPHome component for the C4002.

While it exposes the basic functionality of the sensor, it doesn't provide access to many configuration parameters that are required for proper tuning.

Without those settings, I noticed several issues:

measured distances were noticeably larger than the actual distance,
readings fluctuated significantly while moving,
false detections occurred during the night.

To solve these problems, I rewrote the ESPHome component and implemented the missing configuration commands exposed by the sensor's protocol.

The updated component allows configuring:

sensitivity mode
per-zone detection thresholds
detection parameters
additional diagnostic entities

The complete source code is available on GitHub and linked in the project resources.

Sensor Calibration

After enabling automatic calibration, I reviewed the threshold values generated by the sensor and fine-tuned them for my workshop.

I also switched the sensor to 0.2 m sensitivity mode, which significantly improved distance estimation.

The difference was immediately noticeable.

Before calibration, measured distances could differ from the real position by almost a meter, with large fluctuations while walking.

After calibration and proper threshold tuning, the readings became much more stable and closely matched the actual distance.

Most importantly, the false detections that occasionally occurred during the night disappeared completely.

1 / 2

A Note About mmWave Sensors

Originally, I planned to compare the C4002 directly with another mmWave sensor that I had already been using.

However, testing revealed an unexpected issue.

When both sensors operated simultaneously with overlapping detection zones, they interfered with each other. The C4002 continuously reported presence, while the second sensor became noticeably less accurate.

Although this behavior depends on sensor placement and operating conditions, it serves as an important reminder that multiple mmWave sensors should not monitor the same area without careful planning.

Proper placement is just as important as proper configuration.

Home Assistant Automations

With all entities available in Home Assistant, the automation logic became straightforward.

Instead of embedding complex logic into the microcontrollers, I prefer keeping automations inside Home Assistant. This makes them easier to maintain, debug, and extend without reflashing the devices.

Automatic Lighting

The lighting automation is intentionally simple.

Whenever the C4002 detects presence, the workshop lights are switched on automatically.

If no presence is detected for 15 minutes, Home Assistant assumes that the workshop has been left and switches off the lights together with other non-essential equipment.

During the night, a configurable quiet period disables automatic light activation, preventing the system from turning the lights on because of unexpected detections.

This combination has proven to work reliably in daily use while remaining completely transparent to anyone entering the workshop.

Smart Ventilation

Ventilation control combines information from both sensors.

Every ten minutes Home Assistant checks the current CO2 concentration.

If:

someone is present in the workshop, and
the CO2 level exceeds the configured threshold,

the ventilation fan is switched on automatically.

Once the air quality improves or the workshop becomes empty, the fan is turned off again.

This approach avoids unnecessary fan operation while maintaining comfortable air quality during long work sessions.

Why Home Assistant?

Although ESPHome is capable of running automations locally, Home Assistant provides several advantages for this project:

automation logic can be modified without reflashing devices,
all sensors and actuators are available in one interface,
historical data helps tune thresholds,
dashboards make monitoring easy,
additional automations can be added at any time.

Keeping the devices focused on hardware control while letting Home Assistant handle the decision-making results in a clean separation of responsibilities.

1 / 2

Results

The system has now been running in my workshop for several weeks, and the wired approach has proven to be exactly what I was hoping for.

The lights turn on automatically whenever I enter the workshop and switch off after I leave, eliminating the need to think about them at all.

The ventilation system keeps the CO2 concentration under control during longer work sessions while avoiding unnecessary fan operation when the workshop is empty.

Just as importantly, the manual wall switches continue to operate independently of Home Assistant, so the workshop remains fully functional even if the automation system is temporarily unavailable.

Using Ethernet instead of Wi-Fi has also been a success. Communication has been completely stable, and I no longer have to worry about wireless coverage or battery-powered devices.

Lessons Learned

Building this project taught me several valuable lessons that may help others planning a similar system.

Plan the wiring before finishing the room. Adding Ethernet cables during renovation is inexpensive compared to retrofitting them later.
Separate sensing from switching. Using dedicated ESPHome nodes makes the system easier to maintain and expand.
Hardware safety is just as important as software logic. Mechanical interlocks and feedback contacts can prevent failures that software alone cannot.
Spend time calibrating mmWave sensors. Proper calibration significantly improves detection quality and reduces false positives.
Keep automation logic in Home Assistant whenever possible. It simplifies maintenance and allows rapid iteration.

Future Improvements

Although the system already meets my current needs, there are several ideas I'd like to explore in the future:

powering the sensor node via PoE instead of a separate 5 V supply,
adding energy monitoring for workshop equipment,
expanding the control panel with additional Ethernet I/O modules,
migrating to the official ESPHome STCC4 component once it is merged.

Conclusion

Building a wired automation system required more planning than installing a collection of Wi-Fi smart devices, but the result has been well worth the effort.

The combination of ESPHome, Home Assistant, Ethernet, and the DFRobot C4002 and STCC4 sensors provides a reliable and responsive solution for workshop automation. More importantly, the modular architecture makes the system easy to expand as new requirements emerge.

If you're planning a new workshop or renovating an existing one, I highly recommend considering wired infrastructure from the very beginning. Even if you don't automate everything immediately, having Ethernet available at key locations gives you far more flexibility for future projects.

Schematics

Code

esphome:
  name: workshop-eth-sensors
  friendly_name: workshop-eth-sensors

esp32:
  board: wt32-eth01
  framework:
    type: esp-idf

external_components:
  - source: github://pr#14037
  # - source:
  #     type: git
  #     url: https://github.com/uncle-yura/esphome-stcc4
  #     ref: main
    components: [stcc4]
    
  - source:
      type: git
      url: https://github.com/uncle-yura/esphome-c4002
      ref: main
    components: [ c4002 ]
    
# Enable logging
logger:
  level: INFO

# Enable Home Assistant API
api:
  encryption:
    key: "your-encryption-key"

ota:
  - platform: esphome
    password: "your ota password"

ethernet:
  type: LAN8720
  mdc_pin: GPIO23
  mdio_pin: GPIO18
  clk:
    pin: GPIO0
    mode: CLK_EXT_IN
  phy_addr: 1
  power_pin: GPIO16

i2c:
  sda: GPIO15
  scl: GPIO14
  scan: true
  id: bus_a
  frequency: 10kHz

uart:
  id: uart_bus
  tx_pin: GPIO17
  rx_pin: GPIO05
  baud_rate: 115200
  
c4002:
  id: my_c4002
  
binary_sensor:
  - platform: c4002
    c4002_id: my_c4002
    has_target:
      name: Presence
    has_moving_target:
      name: Moving Target
    has_still_target:
      name: Still Target
  
sensor:
  - platform: stcc4
    co2:
      name: "CO2 Concentration"
    temperature:
      name: "Temperature"
      filters:
        - calibrate_linear:
            method: least_squares
            datapoints:
              - 14.7 -> 11
              - 16.5 -> 12
              - 17.5 -> 13
              - 18.1 -> 14
              - 27.4 -> 23
              - 28.07 -> 26.5
    humidity:
      name: "Humidity"
    ambient_pressure_compensation: 990
    update_interval: 60s
  
  - platform: c4002
    c4002_id: my_c4002
    light:
      name: Light
    still_energy:
      name: Still Energy
    still_distance:
      name: Still Distance
    still_gate_index:
      name: Gate Index
    moving_distance:
      name: Moving Distance
    moving_energy:
      name: Moving Energy
    moving_speed:
      name: Moving Speed
      
text_sensor:
  - platform: c4002
    c4002_id: my_c4002
    message:
      name: "C4002 log"
    version:
      name: Version
    direction:
      name: Direction

button:
  - platform: restart
    name: "Restart"
  
  - platform: c4002
    restart:
      name: "Restart C4002"
    factory_reset:
      name: "Factory Reset"
    calibrate:
      name: "Calibrate"
      
switch:
  - platform: c4002
    output_led:
      name: "Output LED Switch"
    run_led:
      name: "Run LED Switch"

select:
  - platform: c4002
    c4002_id: my_c4002
    output_mode:
      name: "OUT Mode"
    distance_resolution:
      name: Distance resolution
    baud_rate:
      name: Baud Rate
      initial_value: "115200"
      restore_value: true
      
number:
  - platform: c4002
    max_distance:
      name: "Max detection distance"
    min_distance:
      name: "Min detection distance"
    light_threshold:
      name: "Light Threshold"
    timeout:
      name: "Target Disappear Delay Time"
    lock_timeout:
      name: "Lock detection timeout"

    g0:
      move_threshold:
        name: G0 move threshold
      still_threshold:
        name: G0 still threshold
    g1:
      move_threshold:
        name: G1 move threshold
      still_threshold:
        name: G1 still threshold
    g2:
      move_threshold:
        name: G2 move threshold
      still_threshold:
        name: G2 still threshold
    g3:
      move_threshold:
        name: G3 move threshold
      still_threshold:
        name: G3 still threshold
    g4:
      move_threshold:
        name: G4 move threshold
      still_threshold:
        name: G4 still threshold
    g5:
      move_threshold:
        name: G5 move threshold
      still_threshold:
        name: G5 still threshold
    g6:
      move_threshold:
        name: G6 move threshold
      still_threshold:
        name: G6 still threshold
    g7:
      move_threshold:
        name: G7 move threshold
      still_threshold:
        name: G7 still threshold
    g8:
      move_threshold:
        name: G8 move threshold
      still_threshold:
        name: G8 still threshold
    g9:
      move_threshold:
        name: G9 move threshold
      still_threshold:
        name: G9 still threshold
    g10:
      move_threshold:
        name: G10 move threshold
      still_threshold:
        name: G10 still threshold
    g11:
      move_threshold:
        name: G11 move threshold
      still_threshold:
        name: G11 still threshold
    g12:
      move_threshold:
        name: G12 move threshold
      still_threshold:
        name: G12 still threshold
    g13:
      move_threshold:
        name: G13 move threshold
      still_threshold:
        name: G13 still threshold
    g14:
      move_threshold:
        name: G14 move threshold
      still_threshold:
        name: G14 still threshold
    g15:
      move_threshold:
        name: G15 move threshold
      still_threshold:
        name: G15 still threshold
    g16:
      move_threshold:
        name: G16 move threshold
      still_threshold:
        name: G16 still threshold
    g17:
      move_threshold:
        name: G17 move threshold
      still_threshold:
        name: G17 still threshold
    g18:
      move_threshold:
        name: G18 move threshold
      still_threshold:
        name: G18 still threshold
    g19:
      move_threshold:
        name: G19 move threshold
      still_threshold:
        name: G19 still threshold
    g20:
      move_threshold:
        name: G20 move threshold
      still_threshold:
        name: G20 still threshold
    g21:
      move_threshold:
        name: G21 move threshold
      still_threshold:
        name: G21 still threshold
    g22:
      move_threshold:
        name: G22 move threshold
      still_threshold:
        name: G22 still threshold
    g23:
      move_threshold:
        name: G23 move threshold
      still_threshold:
        name: G23 still threshold
    g24:
      move_threshold:
        name: G24 move threshold
      still_threshold:
        name: G24 still threshold

substitutions:
  friendly_name: workshop-plc
  
esphome:
  name: workshop-plc
  friendly_name: ${friendly_name}

esp32:
  variant: esp32
  framework:
    type: esp-idf
    advanced:
      minimum_chip_revision: "3.1"

logger:
  baud_rate: 0

api:
  encryption:
    key: "your-encryption-key"

ota:
  - platform: esphome

external_components:
  - source: github://kecajtop/dtr0xx_io@master
    refresh: 60s
    components:
      - dtr008v2io
    
ethernet:
 type: JL1101
 mdc_pin: 23
 mdio_pin: 18
 clk_mode: GPIO17_OUT
 power_pin: 0
 phy_addr: 1

uart:
  id: mod_bus
  tx_pin: 1
  rx_pin: 3
  baud_rate: 9600
  stop_bits: 1

spi:
  - id: dtr008v2io_hub_spi
    interface: hardware
    clk_pin: GPIO14
    mosi_pin: GPIO13
    miso_pin: GPIO16
  
dtr008v2io:
  - id: dtr008v2io_hub
    oe_pin: GPIO32
    spi_id: dtr008v2io_hub_spi
    cs_pin: GPIO15

binary_sensor:
  - platform: gpio
    id: input_1
    name: ${friendly_name} Input 1
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 0
      inverted: true
      allow_other_uses: true
    filters:
      - delayed_on: 10ms
      - delayed_off: 10ms

  - platform: gpio
    name: ${friendly_name} Input 2
    id: input_2
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 1
      inverted: true
      allow_other_uses: true
    filters:
      - delayed_on: 10ms
      - delayed_off: 10ms

  - platform: gpio
    name: ${friendly_name} Input 3
    id: input_3
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 2
      inverted: true
      allow_other_uses: true
    filters:
      - delayed_on: 10ms
      - delayed_off: 10ms

  - platform: gpio
    name: ${friendly_name} Input 4
    id: input_4
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 3
      inverted: true
      allow_other_uses: true
    filters:
      - delayed_on: 10ms
      - delayed_off: 10ms

  - platform: gpio
    name: ${friendly_name} Input 5
    id: input_5
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 4
      inverted: true
      allow_other_uses: true
    filters:
      - delayed_on: 10ms
      - delayed_off: 10ms

  - platform: gpio
    name: ${friendly_name} Input 6
    id: input_6
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 5
      inverted: true
      allow_other_uses: true
    filters:
      - delayed_on: 10ms
      - delayed_off: 10ms

  - platform: gpio
    name: ${friendly_name} Input 7
    id: input_7
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 6
      inverted: true
      allow_other_uses: true
    filters:
      - delayed_on: 10ms
      - delayed_off: 10ms

  - platform: gpio
    name: ${friendly_name} Input 8
    id: input_8
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 7
      inverted: true
      allow_other_uses: true
    filters:
      - delayed_on: 10ms
      - delayed_off: 10ms

switch:
  - platform: gpio
    name: ${friendly_name} Relay 1
    id: relay_1
    restore_mode: ALWAYS_OFF
    interlock: [relay_2, relay_3]
    interlock_wait_time: 250ms
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 0
      inverted: false
      allow_other_uses: true
      
  - platform: gpio
    name: ${friendly_name} Relay 2
    id: relay_2
    restore_mode: ALWAYS_OFF
    interlock: [relay_1, relay_3]
    interlock_wait_time: 250ms
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 1
      inverted: false
      allow_other_uses: true
      
  - platform: gpio
    name: ${friendly_name} Relay 3
    id: relay_3
    restore_mode: ALWAYS_OFF
    interlock: [relay_1, relay_2]
    interlock_wait_time: 250ms
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 2
      inverted: false
      allow_other_uses: true
      
  - platform: gpio
    name: ${friendly_name} Relay 4
    id: relay_4
    restore_mode: ALWAYS_OFF
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 3
      inverted: false
      allow_other_uses: true
      
  - platform: gpio
    name: ${friendly_name} Relay 5
    id: relay_5
    restore_mode: ALWAYS_OFF
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 4
      inverted: false
      allow_other_uses: true
      
  - platform: gpio
    name: ${friendly_name} Relay 6
    id: relay_6
    restore_mode: ALWAYS_OFF
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 5
      inverted: false
      allow_other_uses: true
      
  - platform: gpio
    name: ${friendly_name} Relay 7
    id: relay_7
    restore_mode: ALWAYS_OFF
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 6
      inverted: false
      allow_other_uses: true
      
  - platform: gpio
    name: ${friendly_name} Relay 8
    id: relay_8
    restore_mode: ALWAYS_OFF
    pin:
      dtr008v2io: dtr008v2io_hub
      number: 7
      inverted: false
      allow_other_uses: true

Credits

Craftiarenko

7 projects • 13 followers

Making simple things difficult :)

Thanks to kecajtop and will-tm.

Embed the widget on your own site

Building a Wired Smart Workshop with ESPHome and Ethernet

Building a Wired Smart Workshop with ESPHome and Ethernet

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Why Wired Instead of Wi-Fi?

System Overview

Hardware

Why a PLC Instead of Individual Smart Relays?

Building the Control Panel

Wiring

Lighting Control with Manual Override

Safe Fan Speed Selection

Why Ethernet?

Flashing the DT-R008

Sensor Node

STCC4 CO2 Sensor

ESPHome Support

C4002 mmWave Presence Sensor

Improving the ESPHome Component

Sensor Calibration

A Note About mmWave Sensors

Home Assistant Automations

Automatic Lighting

Smart Ventilation

Why Home Assistant?

Results

Lessons Learned

Future Improvements

Conclusion

Custom parts and enclosures

Sensor Cover

Sensor Panel

Schematics

Relay schematic

Sensor schematic

Code

ESPHome Sensors Configuration

esphome-plc.yaml

Credits

Craftiarenko

Comments

Related channels and tags