Brand Story
Smart-home clarity wrapped in a polished product story.
The current explanation page keeps its advertising energy here.
Making Of
Sketches, build decisions, prototypes, and the path behind the idea.
This view turns the project into a making-of documentation.
Today, most smart home systems are still guessing. Motion sensors trigger lights even when no one is really using a room. Heating schedules are static. The most essential information is missing:
Which room is currently in use – and by how many people?
The Gate solves this problem by rethinking the door as the central interface of the smart home.
Instead of adding more sensors to ceilings or walls, The Gate replaces only one component: the standard mortise lock. Thanks to the DIN 18251 standard, which has been established for over 100 years, this solution can be installed in almost every German household – rental apartment, old building, or new construction – without drilling, rewiring, or visible hardware.
But knowing which room is occupied is only half the equation.
The other half is what happens next. Most smart home platforms still make presence-based automation feel like engineering work: navigating dashboards, writing automation scripts, and stitching together abstract helper entities just to turn off the lights when someone leaves a room.
Qyra changes that. It is the interface The Gate was always meant to have: a smart home UI that thinks in rooms, not entities. You see your floor plan, you see who is where, and you set what should happen without a single line of YAML.
Lights, heating, scenes, and schedules all follow the same logic: the room knows who is in it, and Qyra knows what to do.
Designed to run alongside Home Assistant, Qyra keeps the flexibility and device compatibility of the world’s most powerful open home automation platform and replaces the only thing that was ever missing: a surface that anyone can actually use.
The Gate precisely differentiates between:
By detecting direction, movement, and interaction at the door itself, it knows when a room is actually being used. This enables truly smart behavior:
On top of that, The Gate introduces a new way of interacting with doors:
The door becomes an interface – not just a barrier.
Inside the lock, The Gate combines multiple sensors:
All components are powered by a large internal battery, allowing a runtime of up to 9 months on a single charge.
Communication is handled via Zigbee, using an ESP32-H2, making the system compatible with existing smart home ecosystems. The Gate does not add more devices to your home. It upgrades what is already there.
The door to truly smart homes is already built. makes it intelligent.
This project presents the first functional implementation of Qyra, a self-developed smart home platform built around a new way of thinking about presence in the home. The final consists of two closely connected components: Qyra | The Gate, a custom hardware device installed at a doorway, and the Qyra UI, the interface through which the system is configured and controlled.
The Gate is built on an ESP32-H2 microcontroller paired with a VL53L5CX time-of-flight sensor. Using an 8x8 distance matrix captured at the doorway, it detects in real time whether a person is entering or leaving a room. All processing happens locally on the microcontroller itself: no cloud service, no external server, no round-trip to a backend. The ESP32-H2 derives the relevant states directly from the raw sensor data and publishes them as structured events into the local network, keeping latency minimal and the system fully independent of any internet connection.
These events are picked up by the Qyra Backend, a lightweight application running on a Raspberry Pi in the local home network. The backend connects to Home Assistant, the open-source device integration platform that manages all smart home hardware in the background, and uses the presence events from The Gate to trigger device control across the entire home. Lights, heating, switches, and any other Home Assistant-connected device can be configured to respond automatically when a room becomes occupied or vacant.
This configuration is handled entirely through the Qyra UI: a modern, browser-based interface that presents the home as a floor plan, maps The Gate devices to their respective doorways, and lets users define room-level device behaviour without writing automations or managing abstract helper entities.
Home Assistant and the Qyra Backend are designed to run on the same Raspberry Pi, sharing a single piece of hardware with minimal overhead. They can equally be separated onto individual devices if a particular setup requires it, making the architecture flexible from the start.
The scope of this final project is deliberately focused: the goal is to demonstrate the core loop in a working state. A person walks through a door, The Gate detects the direction of movement, the Qyra system identifies which room has been entered or vacated, and the connected devices respond accordingly. Everything is configured and monitored through the Qyra UI.
The project was organized through a task board and calendar view, making it easier to keep track of open decisions, planned milestones, and the time available for each part of the build.
The task overview keeps the build process structured, from open decisions to finished milestones.
The calendar maps project phases, test windows, and documentation steps across the available time.
This diagram shows how the system works, where data is transmitted, and how results are calculated from the first input to the final output.
Door Hardware, Electronics and Handle Integration
Physical integration is the main constraint of The Gate because the system has to fit into the geometry of a standard German interior door and follow the spatial logic defined by DIN 18251, while still disappearing into the existing lock and handle assembly.
The design therefore treats standards, packing, lock mechanics, capacitive sensing, haptic feedback, and power transfer as one compact mechanical-electrical stack. Every signal path and component position has to support the door hardware first, so the system can remain robust, cable-minimal, and installable in a real lock body.
The physical design is built around DIN 18251 and the geometry of a typical German interior door. This makes the standard itself one of the largest constraints: the lock, handle position, square spindle, latch movement, and surrounding installation space have to stay within the expected dimensions instead of being freely redesigned around the electronics.
Using a standard room door as the base keeps the prototype close to a real installation scenario. The goal is not to create a special demonstration door, but to make The Gate fit into the same mechanical conditions that already exist in everyday interior doors.
The internal packing is designed to avoid loose cables wherever possible. Most connections are routed as PCB traces and the board is populated with SMD components, so the electronics remain compact, fixed in place, and less vulnerable to movement inside the lock body.
The ToF sensor requires a 90 degree direction change to face the doorway correctly. The current plan is to solve this with 90 degree Dupont pins and headers, although this connection is still being evaluated. For possible I2C extensions, JST connectors are planned; because the battery takes up the available internal space, this may become the only cable connection and would be fixed to the lower part of the housing.
The square spindle is also planned without cables running through or around it. Keeping the spindle mechanically clean makes the lock safer to install and should make the assembly more resistant to drops and repeated impacts.
The door is locked with an N20 motor. Its gearbox makes it extremely difficult to push the handle down once the mechanism is engaged. The motor moves roughly 10 degrees to block the follower, making the door almost impossible to open.
The mechanism was designed with the user experience in mind: the geometry allows a complete lock action within approximately 80 ms.
To make the system controllable through the handle itself, the handle becomes part of the capacitive sensing path. One signal is routed through the handle and the GND connection to the capacitive sensor.
On the opposite side, the VCC connection carries the signal to a second sensor pin. A P-MOSFET switches this path between capacitive sensing and power delivery.
A vibration motor gives the user quiet, immediate feedback. It is powered through an N-MOSFET, with current flowing through the VCC layer and returning through GND.
During vibration, the P-MOSFET disconnects the line from the touch sensor to protect the IC. Touch data is unavailable for that short moment, but the system avoids additional data lines through the handle shaft.
The power system carries both GND and VCC while also serving as the electrode path for touch sensing. On the shown side, the electrode runs through GND; on the opposite side, it runs through VCC.
A slip-ring-like contact keeps GND and VCC connected even while the follower rotates. Spring-loaded contacts press against the handle shaft, which is inserted through the lock like a normal door handle shaft. The gearbox remains fixed inside the lock.
Local Events, Room Logic, Home Assistant Control
The software integration keeps The Gate local: the ESP32-H2 turns raw sensor input into doorway events, while Home Assistant remains the compatibility layer for Matter, Thread, Zigbee, Wi-Fi, and MQTT devices.
Qyra sits above that device layer and translates technical state changes into room-level behavior, so the interface can describe what should happen in a space instead of exposing users to entity names and automation plumbing.
The ESP32-H2 on The Gate continuously reads all sensor values: the ToF matrix, gyroscope, and capacitive touch sensor. All processing happens directly on the chip.
The result is a structured event, for example { direction: "enter", room: "living_room" }. This event is transmitted over Thread, an IPv6-based mesh protocol that operates without Wi-Fi overhead.
A Thread Border Router, for example the Home Assistant SkyConnect ZBT-2 or Home Assistant Yellow, connects the Thread mesh to the regular IP home network.
It translates Thread packets into standard IPv6 traffic. From this point on, The Gate is addressable like any other network device.
Home Assistant runs the OpenThread Border Router as an add-on and manages the Thread network directly. The Gate registers with Home Assistant via Matter over Thread through a simple QR code commissioning process.
After that, it appears in Home Assistant as a device with its own entities, such as binary_sensor.the_gate_presence or sensor.the_gate_direction.
The Qyra Backend maintains a persistent WebSocket connection to Home Assistant at /api/websocket and subscribes to all state_changed events.
As soon as Home Assistant registers a state change from The Gate, or from any other device, the backend receives it in real time.
The backend also sends control commands back to Home Assistant through the same WebSocket connection. These commands are triggered automatically by user-defined room reactions in the Qyra UI, or manually when a user controls a device in the interface.
In both cases, the backend calls the appropriate Home Assistant service, such as light.turn_on, climate.set_temperature, or switch.toggle. Home Assistant executes the command and controls the physical device.
The backend simultaneously maintains a WebSocket connection to the frontend via socket.io, forwarding processed events and current device states in real time.
The frontend never communicates directly with Home Assistant. It talks exclusively to the Qyra Backend.
The React app in the browser receives events and updates the UI immediately: which room is occupied, which devices are active, and what The Gate is currently detecting.
Control commands from the UI, such as manually switching a light, travel back through the same path: Frontend to Backend to Home Assistant to Device.
Beyond The Gate and Thread devices, Home Assistant integrates the full range of hardware found in a typical smart home. Zigbee devices can run through ZHA or Zigbee2MQTT, Wi-Fi devices connect through their Home Assistant integrations, and MQTT devices publish to a broker that Home Assistant subscribes to.
From the Qyra Backend's perspective, the connection method does not matter. It sees one consistent API surface and one unified device model.
Lights and heating only activate when a room is occupied
A Time-of-Flight sensor to detect movement direction
A gyroscope to read door state and enable low-power modes
Capacitive sensors and vibration motors in the door handle for interaction and feedback
