---
title: "Introduction"
space: "Factory Docs"
url: "https://factory.uga.edu/docs/home-assistant"
updated: "2026-11-17"
---

# Home Assistant

[Home Assistant](https://www.home-assistant.io/) is an open-source automation and integration platform. Although it originated around home automation, we use it more broadly as a **cyber-physical integration layer** for the Innovation Factory: a common place where sensors, actuators, embedded controllers, equipment, software services, dashboards, and automation logic can be connected.

Our main instance is available at [ha.factory.uga.edu](https://ha.factory.uga.edu/).

> For account access, UGA ArchPass SSO, and administrator permissions, see the [**Permissions and Authentication**](/docs/home-assistant/permissions) sub-page.

## What Home Assistant Provides

Home Assistant gives us a shared abstraction over otherwise heterogeneous hardware and software. Integrations expose their state and capabilities as entities, which can then be consumed by dashboards, automations, templates, scripts, and other integrations.

For our purposes, its important roles are:

- **Integration** — provide a common interface to devices and services that would otherwise have independent APIs and protocols.
- **State management** — maintain a live representation of sensors, equipment, controls, and derived system state.
- **Visualization** — build dashboards for operators, researchers, demonstrations, and debugging.
- **Automation and orchestration** — react to state changes and coordinate actions among multiple components.
- **Rapid integration** — connect experimental hardware without first building a complete custom web application and backend.

Home Assistant supports a large ecosystem of integrations, including ESPHome and MQTT, making it particularly useful as the software layer between embedded devices and higher-level applications.

## How We Use It

At the Innovation Factory, Home Assistant is not just a building-control dashboard. We use it as infrastructure for **research testbeds and cyber-physical systems**.

A typical system looks conceptually like this:

```PlainText
Sensors / Embedded Controllers / Equipment
                 |
        ESPHome, MQTT, APIs, etc.
                 |
                 v
          Home Assistant
       +---------+----------+
       |         |          |
    Entities  Automation  Services
       |         |          |
       +---------+----------+
                 |
                 v
       Dashboards / Operators
       Research Applications
       Experimental Workflows
```

This lets the embedded layer remain focused on the functions that belong close to the hardware, while Home Assistant handles integration, system-level state, user interfaces, and coordination between components.

## IFCAT: Cyber-Physical Assembly Testbed

A major example is the [Innovation Factory Cyber-Physical Assembly Testbed (IFCAT)](https://git.factory.uga.edu/UGA-Innovation-Factory/ifcat). The repository describes a modular multi-station manual assembly testbed with Home Assistant as its backend architecture.

IFCAT demonstrates the role Home Assistant can play in a research system rather than a conventional smart-home deployment.

### Embedded and Physical Layer

IFCAT uses ESP32-based devices and ESPHome firmware to interact with physical equipment. Its current architecture includes:

- Eight HX711 load-cell bins per assembly station.
- M5StickC Plus 2 smart artifacts with MPU6886 IMU sensing.
- Optical encoder-based RPM quality verification.
- BLE iBeacon broadcasting for artifact localization.
- Stepper-driven quality-control equipment.

Time-sensitive signal processing remains on the embedded hardware. For example, the load-cell firmware performs filtering and stability logic locally, while the smart artifact performs IMU sampling and sensor fusion before publishing higher-level state.

### Telemetry and State

Embedded nodes publish measurements into the system through ESPHome and MQTT. IFCAT includes high-frequency MQTT telemetry for its assembly stations and 25 Hz orientation updates from its smart artifacts.

Home Assistant then provides a common state model that the rest of the testbed can consume. Instead of every dashboard or experiment independently implementing communication with each sensor, those components can work against Home Assistant entities and services.

### System-Level Logic

IFCAT's Home Assistant configuration adds logic above the device layer. This includes:

- A master parts catalog.
- Per-bin part assignment and unit-weight synchronization.
- Tracking part consumption during assembly.
- Bill of Materials verification.
- Quality-check logic using measured RPM.
- Commands for the stepper-based quality-control rig.

Reusable Jinja templates calculate station part inventory, picked parts, and artifact BOM status. Home Assistant therefore acts not only as a visualization layer but also as part of the testbed's system-level state and orchestration architecture.

### Dashboards

IFCAT also uses Home Assistant dashboards as the human-machine interface to the testbed. The repository contains dashboard definitions for:

- The complete assembly line.
- Station load-cell and bin state.
- Master parts catalog management.
- Quality-control status and rig controls.
- A real-time 3D visualization of smart-artifact orientation.

The 3D view is a useful example of extending Home Assistant beyond its standard UI components: IFCAT includes a custom Three.js dashboard component that renders a GLB model and updates its orientation from live IMU data.

## Configuration as Code

Where practical, our more substantial Home Assistant projects should be treated as **software projects**, not only as configuration entered through the web interface.

IFCAT is an example of this approach. Its repository mirrors important parts of a production Home Assistant `/config` layout, including:

```PlainText
configuration.yaml
custom_templates/
dashboards/
esphome/
packages/
www/
```

Keeping these components under Git gives us version history, reviewable changes, reproducibility, and a clearer path for moving an experimental configuration between development and production systems.

For IFCAT-specific configuration, firmware, wiring documentation, dashboards, and engineering details, use the [IFCAT repository](https://git.factory.uga.edu/UGA-Innovation-Factory/ifcat) as the authoritative project reference.

## Design Boundary

Home Assistant is most useful to us when it is treated as the **integration and orchestration layer**, rather than as the implementation location for every part of a system.

A useful rule of thumb is:


| Concern                                                 | Preferred location                             |
| ------------------------------------------------------- | ---------------------------------------------- |
| Hardware drivers and direct I/O                         | Embedded firmware / ESPHome                    |
| Fast sampling and time-critical control                 | Embedded controller or dedicated application   |
| Signal processing tightly coupled to a sensor           | Embedded controller where practical            |
| Device and service integration                          | Home Assistant                                 |
| Cross-device state and coordination                     | Home Assistant                                 |
| Operator dashboards and controls                        | Home Assistant                                 |
| Experimental algorithms or compute-intensive processing | Dedicated research software / compute platform |
| Reproducible HA configuration                           | Git-managed project repository                 |


This separation matters as testbeds grow. Home Assistant is excellent at connecting components and exposing state, but hard real-time control or computationally expensive processing should generally remain outside it.

## Related Pages and Resources

- [**Permissions and Authentication**](/docs/home-assistant/permissions) — UGA ArchPass SSO, read access, and administrator permissions.
- [Main Home Assistant instance](https://ha.factory.uga.edu/)
- [IFCAT repository](https://git.factory.uga.edu/UGA-Innovation-Factory/ifcat)
- [Home Assistant documentation](https://www.home-assistant.io/docs/)
- [Home Assistant integrations](https://www.home-assistant.io/integrations/)