SENSBLUE ATLAS/Home Assistant

Fast installation script

(If you are feeling lazy)

Download Script

This script takes a backup file as an argument and contains: .tar.gz

atlas-ha-installer/
├── docker-compose.yml
├── install.sh
├── README.md
├── provision_areas.py
└── ha-config/
    ├── configuration.yaml
    ├── mqtt.yaml
    ├── automations.yaml
    ├── scripts.yaml
    └── scenes.yaml

1. What the script does

Stage	Action
Validates argument	Confirms that a backup file was specified
Installs dependencies	Run apt update and install docker.io and docker-compose-plugin
Enables Docker	Executes systemctl enable docker and systemctl start docker
Breed pasta	Ensure /opt/atlas-ha exists
Extract backup	Extract the .tar.gz file to /opt/atlas-ha
HA starts up	Navigates to /opt/atlas-ha and runs sudo docker compose up -d
Show URL	Indicate access via http://DEVICE_IP:8123

2. Prepare Device

Transfer the package to ATLAS, for example using WinSCP:

1. Open the connection to ATLAS using WinSCP.
2. Copy atlas-ha-installer.zip or atlas-ha-installer.tar.gz to /home/pi.
3. Drag the folder extracted from the .zip file to the /home/pi directory on ATLAS.

Note: If you need help installing WinSCP, click here.

On ATLAS, after transferring the necessary files, establish an SSH connection

If the package is .zip:

cd /home/pi
unzip atlas-ha-installer.zip
cd atlas-ha-installer

If the package is:.tar.gz

cd /home/pi tar
-xzf atlas-ha-installer.tar.gz
cd atlas-ha-installer

Grant execution permission

chmod +x install.sh

3. Execute installation

The script will install the required dependencies, install/configure Docker, copy the files to /opt/atlas-ha, and start Home Assistant.

sudo ./install.sh

After installation, the following should exist:

/opt/atlas-ha/
├── docker-compose.yml
└── ha-config/
    ├── configuration.yaml
    ├── mqtt.yaml
    ├── automations.yaml
    ├── scripts.yaml
    └── scenes.yaml

4. Post-script validation

Verify that the container is active:

sudo docker ps

Check logs:

sudo docker logs -f homeassistant

Verify HTTP response:

curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8123

Expected result:

Code	Meaning
200	Home Assistant access
302	Home Assistant accessible, with redirection
000 or connection refused	It can be normal for the first 1–2 minutes; wait and repeat.

Access in browser

http://<ip-do-atlas>:8123

Home Assistant integration

Installing Home Assistant on the SENSBLUE ATLAS

Objective Install Home Assistant in a Docker container, running alongside the stack already present on the ATLAS:

• Node-RED

• Mosquitto MQTT
• Grafana
• InfluxDB

Home Assistant does not replace the native stack. It only adds an extra interface/integration layer.

Scope: base installation of Home Assistant, creation of the initial account, and MQTT configuration compatible with the current ATLAS installation.

1. Prerequisites

Item	Value / check
Device	SENSBLUE ATLAS
Platform	Raspberry Pi CM4 / aarch64
System	Debian GNU/Linux 13 trixie
Access	SSH with a user account that has sudo permissions
Disk space	At least 1 GB free on the eMMC
Network	ATLAS with internet access
Required port	8123 free for Home Assistant
MQTT	Local Mosquitto on 127.0.0.1:1883

To locate the IP address of the ATLAS device, toggle the joystick to the right to navigate to the 'Network' screen, where the eth1 address is displayed.

Once your preferred terminal application (e.g., PuTTY) is installed, initiate an SSH session using the ATLAS IP address and execute the following command to verify the system:

Note: If you need help installing PuTTY, click here.

Note: SSH access to the ATLAS device requires authentication.

• Username: pi
• Password: atlas2026

cat /etc/os-release | grep PRETTY_NAME
uname -m
df -h /

Expected output:

PRETTY_NAME="Debian GNU/Linux 13 (trixie)"
aarch64
Filesystem      Size  Used Avail Use% Mounted on
/dev/mmcblk0p2   29G  5.5G   23G  20% /

2. Ports used on ATLAS

Before and after installation, confirm that the existing stack continues to respond.

Service	Port
Node-RED	1880
Mosquitto MQTT	1883
Grafana	3000
InfluxDB	8086
Home Assistant	8123

Check the stack's ports:

for p in 1880 1883 3000 8086; do
ss -tlnp | grep ":$p " && echo "port $p OK"
done

Expected output:

LISTEN 0      511          0.0.0.0:1880       0.0.0.0:*    users:(("node-red",pid=614,fd=19))
porta 1880 OK
LISTEN 0      100          0.0.0.0:1883       0.0.0.0:*                                    
LISTEN 0      100             [::]:1883          [::]:*                                    
porta 1883 OK
LISTEN 0      4096               *:3000             *:*                                    
porta 3000 OK
LISTEN 0      4096               *:8086             *:*  
porta 8086 OK

3. Installing Docker

Install Docker Engine and the Docker Compose plugin through Docker's official Debian repository.

Summary of the process:

1. Update packages.
2. Install dependencies.
3. Add the Docker GPG key.
4. Add the Docker repository.
5. Install Docker Engine and the Docker Compose plugin.
6. Test with hello-world.

3.1 Update packages

sudo apt-get update

3.2 Install dependencies

sudo apt-get install -y ca-certificate curl
sudo install -m 0755 -d /etc/apt/keyrings

3.3 Add Docker GPG key

sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

3.4 Add Docker repository

echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] \ https://download.docker.com/linux/debian \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

3.5 Install Docker Engine and Docker Compose plugin

sudo apt-get update 
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

3.6 Verify if Docker is operational

sudo docker run --rm hello-world

Note on Debian 13 (Trixie)

If apt-get update returns a 404 error for the Docker repository on trixie, temporarily use bookworm in the Docker repository line and re-run the update/installation.

Example of the alternative line:

deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian bookworm stable

4. Create the Home Assistant project

Create the project folder:

sudo mkdir -p /opt/atlas-ha
cd /opt/atlas-ha

Create the docker-compose.yml file:

sudo tee docker-compose.yml > /dev/null << 'EOF'
services:
    homeassistant:
      container_name: homeassistant
      image: ghcr.io/home-assistant/home-assistant:stable
      network_mode: host
      volumes:
        - ./ha-config:/config
        - /etc/localtime:/etc/localtime:ro
      environment:
        - TZ=Europe/Lisbon
      restart: unless-stopped
EOF

Important notes:

Option	Reason
network_mode: host	Allows direct access to the port and local Mosquitto at 127.0.0.1:1883
./ha-config:/config	Stores Home Assistant configuration in /opt/atlas-ha/ha-config
restart: unless-stopped	Automatically restarts Home Assistant after reboot or failure
TZ=Europe/Lisbon	Sets the correct time zone

5. Start Home Assistant

From the /opt/atlas-ha folder:

sudo docker compose up -d

The first start may take a few minutes as the image is downloaded and Home Assistant initialises the configuration. Check container status:

sudo docker ps

Check HTTP response:

curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8123

Expected result:

Code	Meaning
200	Home Assistant accessible
302	Home Assistant accessible, with redirection
000 connection refused	May be normal in the first 1-2 minutes; wait and retry

6. Initial onboarding

Open in a browser on a PC on the same network:

http://<atlas-ip>:8123

Then:

1. Create the administrator account.
2. Set the location, e.g., Portugal, or skip.
3. Complete until you reach the main dashboard.

From this point, Home Assistant is installed and operational.

7. Configure MQTT integration in Home Assistant

Since the container uses network_mode: host, Home Assistant can access the local Mosquitto via:

Field	Value
Broker	127.0.0.1
Port	1883
User/password	As per Mosquitto configuration; blank if no authentication

In Home Assistant:

Settings → Devices & services → Add integration → MQTT

Configure the broker as:

127.0.0.1

After adding the MQTT integration, create the following YAML files to declare the entities used in the current installation.

8. Create configuration.yaml

Enter the Home Assistant configuration folder:

cd /opt/atlas-ha/ha-config

Create or replace the configuration.yaml file:

sudo tee configuration.yaml > /dev/null << 'EOF'
default_config:
frontend:
  themes: !include_dir_merge_named themes
automation: !include automations.yaml
script: !include scripts.yaml
scene: !include scenes.yaml
mqtt: !include mqtt.yaml
EOF

Create the included files if they do not already exist:

sudo touch automations.yaml scripts.yaml scenes.yaml
sudo mkdir -p themes

9. Create mqtt.yaml

Create the file:

cd /opt/atlas-ha/ha-config

sudo tee mqtt.yaml > /dev/null << 'EOF'

sensor:
  - name: "ATLAS AI1"
    unique_id: atlas_ai1
    state_topic: "analogInputs/runtime/out"
    value_template: "{{ value_json.task.taskResult.AI1.result }}"
    unit_of_measurement: "V"
    device_class: voltage
    state_class: measurement

  - name: "ATLAS AI2"
    unique_id: atlas_ai2
    state_topic: "analogInputs/runtime/out"
    value_template: "{{ value_json.task.taskResult.AI2.result }}"
    unit_of_measurement: "V"
    device_class: voltage
    state_class: measurement

  - name: "ATLAS AI3"
    unique_id: atlas_ai3
    state_topic: "analogInputs/runtime/out"
    value_template: "{{ value_json.task.taskResult.AI3.result }}"
    unit_of_measurement: "V"
    device_class: voltage
    state_class: measurement

  - name: "ATLAS AI4"
    unique_id: atlas_ai4
    state_topic: "analogInputs/runtime/out"
    value_template: "{{ value_json.task.taskResult.AI4.result }}"
    unit_of_measurement: "V"
    device_class: voltage
    state_class: measurement


  - name: "ATLAS CPU Usage"
    unique_id: atlas_cpu_usage
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.cpu_percent }}"
    unit_of_measurement: "%"
    device_class: power_factor
    state_class: measurement

  - name: "ATLAS CPU Temperature"
    unique_id: atlas_cpu_temperature
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.cpu_tempC }}"
    unit_of_measurement: "°C"
    device_class: temperature
    state_class: measurement

  - name: "ATLAS CPU0 Frequency"
    unique_id: atlas_cpu0_frequency
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.cpu_freqs.cpu0.frequency_mhz }}"
    unit_of_measurement: "MHz"
    state_class: measurement

  - name: "ATLAS CPU1 Frequency"
    unique_id: atlas_cpu1_frequency
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.cpu_freqs.cpu1.frequency_mhz }}"
    unit_of_measurement: "MHz"
    state_class: measurement

  - name: "ATLAS CPU2 Frequency"
    unique_id: atlas_cpu2_frequency
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.cpu_freqs.cpu2.frequency_mhz }}"
    unit_of_measurement: "MHz"
    state_class: measurement

  - name: "ATLAS CPU3 Frequency"
    unique_id: atlas_cpu3_frequency
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.cpu_freqs.cpu3.frequency_mhz }}"
    unit_of_measurement: "MHz"
    state_class: measurement

  - name: "ATLAS CPU Throttle"
    unique_id: atlas_cpu_throttle
    state_topic: "systemHealth/runtime/out"
    value_template: >
      {% if value_json.task.taskResult.cpu_throttle == "0x0" %}
        No
      {% else %}
        Yes
      {% endif %}

  - name: "ATLAS RAM Usage"
    unique_id: atlas_ram_usage
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.ram_percent }}"
    unit_of_measurement: "%"
    state_class: measurement

  - name: "ATLAS RAM Total"
    unique_id: atlas_ram_total
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.ram_total_mb }}"
    unit_of_measurement: "GB"
    state_class: measurement

  - name: "ATLAS RAM Used"
    unique_id: atlas_ram_used
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.ram_used_mb }}"
    unit_of_measurement: "GB"
    state_class: measurement

  - name: "ATLAS RAM Available"
    unique_id: atlas_ram_available
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.ram_available_mb }}"
    unit_of_measurement: "GB"
    state_class: measurement

  - name: "ATLAS Disk Usage"
    unique_id: atlas_disk_usage
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.disk_percent }}"
    unit_of_measurement: "%"
    state_class: measurement

  - name: "ATLAS Disk Total"
    unique_id: atlas_disk_total
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.disk_total_gb }}"
    unit_of_measurement: "GB"
    device_class: data_size
    state_class: measurement

  - name: "ATLAS Disk Used"
    unique_id: atlas_disk_used
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.disk_used_gb }}"
    unit_of_measurement: "GB"
    device_class: data_size
    state_class: measurement

  - name: "ATLAS Disk Free"
    unique_id: atlas_disk_free
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.disk_free_gb }}"
    unit_of_measurement: "GB"
    device_class: data_size
    state_class: measurement

  - name: "ATLAS eMMC RUL State"
    unique_id: atlas_emmc_rul_state
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.emmc_rul.state }}"

  - name: "ATLAS eMMC RUL Reason"
    unique_id: atlas_emmc_rul_reason
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.emmc_rul.reason }}"

  - name: "ATLAS Uptime"
    unique_id: atlas_uptime_seconds
    state_topic: "systemHealth/runtime/out"
    value_template: "{{ value_json.task.taskResult.uptime_sec }}"
    unit_of_measurement: "s"
    device_class: duration
    state_class: measurement


binary_sensor:
  - name: "ATLAS DI1"
    unique_id: atlas_di1
    state_topic: "digitalInputs/runtime/out"
    value_template: >
      {% if value_json.task.taskResult.DI1.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: "ON"
    payload_off: "OFF"

  - name: "ATLAS DI2"
    unique_id: atlas_di2
    state_topic: "digitalInputs/runtime/out"
    value_template: >
      {% if value_json.task.taskResult.DI2.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: "ON"
    payload_off: "OFF"

  - name: "ATLAS DI3"
    unique_id: atlas_di3
    state_topic: "digitalInputs/runtime/out"
    value_template: >
      {% if value_json.task.taskResult.DI3.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: "ON"
    payload_off: "OFF"

  - name: "ATLAS DI4"
    unique_id: atlas_di4
    state_topic: "digitalInputs/runtime/out"
    value_template: >
      {% if value_json.task.taskResult.DI4.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: "ON"
    payload_off: "OFF"

  - name: "ATLAS eMMC RUL OK"
    unique_id: atlas_emmc_rul_ok
    state_topic: "systemHealth/runtime/out"
    value_template: >
      {% if value_json.task.taskResult.emmc_rul.ok == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: "ON"
    payload_off: "OFF"
    device_class: problem

  - name: "ATLAS eMMC RUL Problem"
    unique_id: atlas_emmc_rul_problem
    state_topic: "systemHealth/runtime/out"
    value_template: >
      {% if value_json.task.taskResult.emmc_rul.ok == false %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: "ON"
    payload_off: "OFF"
    device_class: problem

switch:
  - name: "ATLAS DO1"
    unique_id: atlas_do1
    state_topic: "digitalOutputs/runtime/out"
    command_topic: "digitalOutputs/runtime/in"
    value_template: >
      {% if value_json.task.taskResult.DO1.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO1":true}}}'
    payload_off: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO1":false}}}'
    state_on: "ON"
    state_off: "OFF"

  - name: "ATLAS DO2"
    unique_id: atlas_do2
    state_topic: "digitalOutputs/runtime/out"
    command_topic: "digitalOutputs/runtime/in"
    value_template: >
      {% if value_json.task.taskResult.DO2.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO2":true}}}'
    payload_off: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO2":false}}}'
    state_on: "ON"
    state_off: "OFF"

  - name: "ATLAS DO3"
    unique_id: atlas_do3
    state_topic: "digitalOutputs/runtime/out"
    command_topic: "digitalOutputs/runtime/in"
    value_template: >
      {% if value_json.task.taskResult.DO3.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO3":true}}}'
    payload_off: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO3":false}}}'
    state_on: "ON"
    state_off: "OFF"

  - name: "ATLAS DO4"
    unique_id: atlas_do4
    state_topic: "digitalOutputs/runtime/out"
    command_topic: "digitalOutputs/runtime/in"
    value_template: >
      {% if value_json.task.taskResult.DO4.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO4":true}}}'
    payload_off: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO4":false}}}'
    state_on: "ON"
    state_off: "OFF"
   
  - name: "ATLAS DO5"
    unique_id: atlas_do5
    state_topic: "digitalOutputs/runtime/out"
    command_topic: "digitalOutputs/runtime/in"
    value_template: >
      {% if value_json.task.taskResult.DO5.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO5":true}}}'
    payload_off: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO5":false}}}'
    state_on: "ON"
    state_off: "OFF"

  - name: "ATLAS DO6"
    unique_id: atlas_do6
    state_topic: "digitalOutputs/runtime/out"
    command_topic: "digitalOutputs/runtime/in"
    value_template: >
      {% if value_json.task.taskResult.DO6.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO6":true}}}'
    payload_off: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO6":false}}}'
    state_on: "ON"
    state_off: "OFF"

  - name: "ATLAS DO7"
    unique_id: atlas_do7
    state_topic: "digitalOutputs/runtime/out"
    command_topic: "digitalOutputs/runtime/in"
    value_template: >
      {% if value_json.task.taskResult.DO7.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO7":true}}}'
    payload_off: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO7":false}}}'
    state_on: "ON"
    state_off: "OFF"

  - name: "ATLAS DO8"
    unique_id: atlas_do8
    state_topic: "digitalOutputs/runtime/out"
    command_topic: "digitalOutputs/runtime/in"
    value_template: >
      {% if value_json.task.taskResult.DO8.result == true %}
        ON
      {% else %}
        OFF
      {% endif %}
    payload_on: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO8":true}}}'
    payload_off: '{"origin":"HA","task":{"alias":"SET_DO","taskParams":{"DO8":false}}}'
    state_on: "ON"
    state_off: "OFF"

number:
  - name: "ATLAS AO1"
    unique_id: atlas_ao1
    state_topic: "analogOutputs/runtime/out"
    command_topic: "analogOutputs/runtime/in"
    value_template: "{{ value_json.task.taskResult.AO1.result }}"
    command_template: >
      {"origin":"HA","task":{"alias":"SET_AO","taskParams":{"AO1":{{ value | float }}}}}
    min: 4
    max: 20
    step: 0.1
    unit_of_measurement: "mA"
    mode: slider

  - name: "ATLAS AO2"
    unique_id: atlas_ao2
    state_topic: "analogOutputs/runtime/out"
    command_topic: "analogOutputs/runtime/in"
    value_template: "{{ value_json.task.taskResult.AO2.result }}"
    command_template: >
      {"origin":"HA","task":{"alias":"SET_AO","taskParams":{"AO2":{{ value | float }}}}}
    min: 4
    max: 20
    step: 0.1
    unit_of_measurement: "mA"
    mode: slider
EOF

Notes about this mqtt.yaml

Entity	MQTT Topic	Function
sensor.atlas_ai1 .. ai4	analogInputs/runtime/out	Show analogue readings AI..AI4
binary_sensor.atlas_di1 .. di4	digitalInputs/runtime/out	Show digital input states DI..DI4
switch.atlas_do1 .. do4	digitalOutputs/runtime/in/out	Control and confirm digital outputs DO..DO4

Digital inputs accept two response formats:

{
"result": true
}

or:

{
"state": "high"
}

This allows compatibility with different versions of the Node-RED flow.

10. Restart and validate configuration

Restart Home Assistant:

cd /opt/atlas-ha
sudo docker compose restart

View logs:

sudo docker logs -f homeassistant

Confirm there are no errors related to MQTT or YAML.

In Home Assistant, check for entities similar to:

Entity	Type
sensor.atlas_ai1	Analogue sensor
sensor.atlas_ai2	Analogue sensor
sensor.atlas_ai3	Analogue sensor
sensor.atlas_ai4	Analogue sensor
binary_sensor.atlas_di1	Digital input
binary_sensor.atlas_di2	Digital input
binary_sensor.atlas_di3	Digital input
binary_sensor.atlas_di4	Digital input
switch.atlas_do1	Digital output
switch.atlas_do2	Digital output
switch.atlas_do3	Digital output
switch.atlas_do4	Digital output

11. Simple dashboard in Home Assistant

Once the entities exist, you can create a simple card in the Dashboard.

Example YAML for a Lovelace view:

type: vertical-stack
cards:
  - type: entities
    title: Analog Inputs
    entities:
      - sensor.atlas_ai1
      - sensor.atlas_ai2
      - sensor.atlas_ai3
      - sensor.atlas_ai4

  - type: entities
    title: Digital Inputs
    entities:
      - binary_sensor.atlas_di1
      - binary_sensor.atlas_di2
      - binary_sensor.atlas_di3
      - binary_sensor.atlas_di4

  - type: entities
    title: Digital Outputs
    entities:
      - switch.atlas_do1
      - switch.atlas_do2
      - switch.atlas_do3
      - switch.atlas_do4

12. Test MQTT communication

Install MQTT client if necessary:

sudo apt-get install -y mosquitto-clients

View MQTT messages received by Home Assistant:

mosquitto_sub -h 127.0.0.1 -t 'analogInputs/runtime/out' -v
mosquitto_sub -h 127.0.0.1 -t 'digitalInputs/runtime/out' -v
mosquitto_sub -h 127.0.0.1 -t 'digitalOutputs/runtime/out' -v

Send a test to a digital output:

mosquitto_pub -h 127.0.0.1 -t 'digitalOutputs/runtime/in' -m '{"id":0,"origin":"TEST","task":{"action":"SET","taskParams":{"DO1":{"state":"high"}}}}'

13. Daily operation

Run these commands inside the folder:

cd /opt/atlas-ha

Action	Command
View logs	sudo docker logs -f homeassistant
View status	sudo docker ps
Restart	sudo docker compose restart
Stop	sudo docker compose stop
Start	sudo docker compose start
Update	sudo docker compose pull && sudo docker compose up -d

14. Configuration backup

The ha-config folder contains the Home Assistant state/configuration. Create a backup:

sudo tar czf ~/atlas-ha-backup.tar.gz -C /opt/atlas-ha docker-compose.yml ha-config

15. Automatic installation with script

The current installation can be performed using the script:

install-atlas-ha.sh

This script takes a backup .tar.gz file as an argument and installs/restores Home Assistant in:

/opt/atlas-ha

15.1 Script used

#!/bin/bash
set -e

BACKUP_FILE="$1"
INSTALL_DIR="/opt/atlas-ha"

if [ -z "$BACKUP_FILE" ]; then
  echo "Usage:"
  echo "sudo ./install-atlas-ha.sh atlas-ha-backup.tar.gz"
  exit 1
fi

echo "Installing dependencies..."
sudo apt update
sudo apt install -y docker.io docker-compose-plugin

echo "Enabling Docker..."
sudo systemctl enable docker
sudo systemctl start docker

echo "Creating installation folder..."
sudo mkdir -p "$INSTALL_DIR"

echo "Extracting backup..."
sudo tar -xzvf "$BACKUP_FILE" -C "$INSTALL_DIR"

echo "Starting Home Assistant..."
cd "$INSTALL_DIR"
sudo docker compose up -d

echo "Installation complete."
echo "Access at: http://DEVICE_IP:8123"

15.2 What the script does

Step	Action
Validate argument	Confirms a backup file was specified
Install dependencies	Runs apt update and installs docker.io + docker-compose-plugin
Enable Docker	Runs systemctl enable docker and systemctl start docker
Create folder	Ensures /opt/atlas-ha exists
Extract backup	Extracts the .tar.gz to /opt/atlas-ha
Start HA	Enters /opt/atlas-ha and runs sudo docker compose up -d
Show URL	Indicates access via http://DEVICE_IP:8123

15.3 Prepare files

Copy to ATLAS:

install-atlas-ha.sh
atlas-ha-backup.tar.gz

Example with scp from PC:

scp install-atlas-ha.sh atlas-ha-backup.tar.gz pi@<atlas-ip>:/home/pi/

On ATLAS:

cd /home/pi
chmod +x install-atlas-ha.sh

15.4 Run installation

sudo ./install-atlas-ha.sh atlas-ha-backup.tar.gz

If the backup has a different name, replace in the command:

sudo ./install-atlas-ha.sh <backup-name>.tar.gz

15.5 Expected backup structure

The backup should contain the necessary structure so that, after extraction in /opt/atlas-ha, at least the following exists:

/opt/atlas-ha/

├── docker-compose.yml

└── ha-config/

    ├── configuration.yaml

    ├── mqtt.yaml

    ├── automations.yaml

    ├── scripts.yaml

    └── scenes.yaml

If the backup does not contain docker-compose.yml, the command sudo docker compose up -d will not be able to start Home Assistant.

15.6 Validation after the script

Check if the container is active:

sudo docker ps

View logs:

sudo docker logs -f homeassistant

Check HTTP response:

curl -s -o /dev/null -w "%{http_code}
" http://localhost:8123

Expected result:

Code	Meaning
200	Home Assistant accessible
302	Home Assistant accessible, with redirection
000 connection refused	May be normal in the first 1-2 minutes; wait and retry

Access in browser:

http://<atlas-ip>:8123

16. Uninstall / revert

Stop and remove the container:

cd /opt/atlas-ha
sudo docker compose down

Remove the image:

sudo docker image rm ghcr.io/home-assistant/home-assistant:stable

Optionally, also remove the configuration:

sudo rm -rf /opt/atlas-ha

The native ATLAS stack, including Node-RED, Grafana, InfluxDB, and Mosquitto, is not removed by these steps.

17. Summary

Step	Command / Action
Create folder	sudo mkdir -p /opt/atlas-ha
Create compose	docker-compose.yml with network_mode: host
Start	sudo docker compose up -d
Access	http://<atlas-ip>:8123
Configure MQTT	Broker 127.0.0.1:1883
Create entities	configuration.yaml + mqtt.yaml
Restart	sudo docker compose restart
Logs	sudo docker logs -f homeassistant
Backup	tar from the ha-config folder
Revert	sudo docker compose down