The easiest way would probably be to just flash Home Assistant OS directly onto my Raspberry Pi, but since I want to run a few other things on it, I decided to go with a containerized setup – because, let's be honest, I'm a big fan of containers!

Let's kick things off with the classic: installing Docker on Raspberry Pi OS (64-bit). First up, we'll uninstall any old packages. You can find up to date instructions HERE!

for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove $pkg; done

Next, let's add the Docker repositories to apt, which is what we'll use to pull down all the necessary packages:

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
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

# Add the repository to Apt sources:
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
sudo apt-get update

Let's install all the necessary packages:

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

And finally, let's add the current user to the docker group:

sudo usermod -aG docker $USER;
newgrp docker

Alright, Docker is installed, so now we can finally fire up the container with Home Assistant inside! (You can find more details here). To get the container running, we'll need two things: a folder to store the configuration and our timezone. Let's start by creating that configuration folder for Home Assistant.

mkdir ho_configuration

Since I'm currently in Portugal, my timezone is Europe/Lisbon. Make sure you swap that out for your own – you can find yours here. Also, remember to change /home/tomasz/ho_configuration to your preferred folder. Now that we have all the info, let's fire up the Home Assistant container!

docker run -d \
  --name homeassistant \
  --privileged \
  --restart=unless-stopped \
  -e TZ=Europe/Lisbon \
  -v /home/tomasz/ho_configuration:/config \
  -v /run/dbus:/run/dbus:ro \
  --network=host \
  ghcr.io/home-assistant/home-assistant:stable

Once all the layers of our Home Assistant image have been pulled and installed, you should be able to access the graphical interface by typing localhost:8123 into your browser. Just create an account, fill in the basic details, and you should see the Home Assistant main screen.

Now we need to figure out how to bridge the gap between our console-based BME280 sensor readings and Home Assistant. There are a few ways to tackle this, but to brush up on my skills, I decided to go with a really neat communication standard called MQTT. It's super popular in the IoT world, already integrated with Home Assistant, and just plain simple to use.

MQTT is all about the Publish/Subscribe concept. My sensor will Publish two types of data – temperature and pressure – and Home Assistant will then Subscribe to that data and display it nicely. To handle all these subscribers and publishers, we need a central overseer, which is called a broker. I'll be using a super simple one called Mosquitto.

sudo apt update
sudo apt install mosquitto mosquitto-clients
sudo systemctl enable mosquitto
sudo systemctl start mosquitto

The server's up and running, so now it's time to tweak that script I prepared in the previous post. The data we're collecting and displaying now needs to be published. You publish data to a topic, which is essentially just a string. Before we make any changes, let's install the Python package that supports MQTT, called paho-mqtt (you can find it here).

pip install paho-mqtt

My script will be publishing to localhost, where my Mosquitto server is running, using the default port 1883 and a default keepalive of 60s. I'll be sending data to two topics: bmp280/temp and bmp280/press – we'll use these two strings when configuring Home Assistant in the next step. For now, I'm just running the script in a continuously open command line.

#!/usr/bin/env python

import time
from smbus2 import SMBus
from bmp280 import BMP280
from datetime import datetime
import paho.mqtt.client as mqtt

# Initialise the BMP280
bus = SMBus(1)
bmp280 = BMP280(i2c_dev=bus)

# Initialise MQTT
mqtt_client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
mqtt_client.connect("localhost", 1883, 60)
mqtt_client.loop_start()

while True:
    now = datetime.now()
    formatted = now.strftime("%y-%m-%d %H:%M:%S")
    temperature = bmp280.get_temperature()
    pressure = bmp280.get_pressure()
    print(formatted,f" -  {temperature:05.2f}*C {pressure:05.2f}hPa")
    mqtt_client.publish("bmp280/temp", round(temperature, 2))
    mqtt_client.publish("bmp280/press", round(pressure, 2))
    time.sleep(60)

The data should be flowing to the broker every minute, so now we can dive into configuring Home Assistant, which, luckily, has plugin supporting MQTT . You'll need to head into Settings, then "Devices & services", click "Add Integration" in the bottom right corner, and search for MQTT. A basic configuration window will pop up where you just need to enter the hostname, which is simply "localhost"

Next, go into the MQTT integration, click the three dots next to "localhost," and then select "Add MQTT Device." Choose a name like our sensor's name, "BME280." After moving forward, pick "sensor" as the entity type and add "Temperature" as the first reading, along with the reading in Celsius. (Once you type "C" and click next, it should automatically suggest the correct unit, °C.) And most importantly, for the topic name, enter "BME280/temp."

Great, the measurement has been added correctly! You can add the pressure reading in a similar way. You'll see the option "Add another entity to BME280" in the current window, or you can do it directly from the MQTT integration window. When adding the pressure reading, just remember to use hPa as the unit and "BME280/press" as the topic name.

Both measurements are now added! Let's try displaying them on the main screen. Go to the Overview tab and click the pencil icon in the top right corner. In the bottom right, select "Add Card." Then, under the "Entity" tab, find both Pressure and Temperature from your BME280 sensor. And just like that, we've successfully got our BME280 sensor readings into Home Assistant.

I really encourage you to play around with the widgets for displaying values. There's a ton of possibilities there that even I haven't fully explored yet.

I left the sensor running for two days of measurements. During that time, the readings froze for a few hours and only unfroze after I manually searched for the sensor on the I2C bus and restarted the script. Both the script and how it's launched will naturally be improved, but that's for the next post! Below, you can see the measurements from those two days.

What are my assumptions about the sensor itself? Very simple - it has to be cheap, measure pressure, it would be nice if it also measured temperature, and it has to be widely used - I don't want to write controllers from scratch. I settled on the BMP280 sensor. It meets all the requirements!

The sensor can measure pressure from 300 to 11000 hPa and temperature from -40 to 85 °C. I can communicate with it via I2C and SPI interfaces. Libraries, examples and development boards are available.

I will connect the sensor to the Raspberry via the I2C bus, which is a serial and synchronous bus using two communication lines:

• SCL - the clock line, which, like a conductor, sets the rythm of communication,

• SDA - the line on which the actual communication takes place.

Besides the communication lines, the GND (ground) line must be connected — you need to know the reference point against which to measure the potentials on the lines.

The sensor needs to know which bus to use - there is a choice of I2C and SPI buses. The CSB line is used to select the bus: a logic 1 (3.3 V) state selects the I2C bus, while a logic 0 (0 V) state selects the SPI bus. Below I show the sensor connection from my Raspberry Pi to the I2C1 interface.

After connecting everything, we need to enable the I2C bus. We can do this in two ways — through the graphical interface:

Or via the command line:

sudo raspi-config

I had some minor issues getting the sensor started, so I’d suggest rebooting the Raspberry after enabling the interface.

The next step should be to verify if we connected the sensor correctly and if we can find its address. For that, we’ll need the tool i2cdetect.

sudo apt update
sudo apt install -y i2c-tools

We connected the device to the I2C1 bus — dedicated for connecting external sensors. I2C0 is reserved for the Raspberry hat with EEPROM. To find the sensor on the I2C1 bus, use the following command:

i2cdetect -y 1

Success! The sensor is available at address 0x76!

So let’s write some simple code to read the sensor’s parameters: pressure and temperature! Let’s create a project folder, start a virtual environment, install a ready-made Python library, and create a script file:

mkdir temppressread
cd temppressread/
python -m venv temppressread
source temppressread/bin/activate
pip install bmp280
touch run.py

Using the examples available on the library’s website, let’s create a simple script to read temperature and pressure, then run it!

#!/usr/bin/env python

import time
from smbus2 import SMBus
from bmp280 import BMP280
from datetime import datetime

# Initialise the BMP280
bus = SMBus(1)
bmp280 = BMP280(i2c_dev=bus)

while True:
    now = datetime.now()
    formatted = now.strftime("%y-%m-%d %H:%M:%S")
    temperature = bmp280.get_temperature()
    pressure = bmp280.get_pressure()
    print(formatted,f" -  {temperature:05.2f}*C {pressure:05.2f}hPa")
    time.sleep(1)

The sensor and the script are working! Next, I’ll try installing Home Assistant on the Raspberry and somehow connect this data so I can track it with nice charts and monitor the historical data!

My setup consists of a Raspberry Pi 4 Model B with 1 GB of RAM, a cute, mini, used 7-inch monitor, a classic HDMI cable with a micro HDMI adapter, and a standard USB-C charger.

After connecting everything, a screen appears informing me about the type of board, boot method, missing SD card, network interface information, and HDMI output connection. The board doesn't have the operating system that should be on the missing memory card. But other than that – everything works!

Let's go ahead and flash the dedicated operating system onto this device, which is Raspberry Pi OS. The easiest way will be to download the Raspberry Imager program – it prepares the SD card with the system. The program is very intuitive! I choose the board version, the system I want to install, and the storage device where I want to write the operating system – the SD card that will be inserted into the Raspberry. This is how it looks for me:

After confirming that I’m aware of the data removal from the card and accepting the use of personalized data, such as the Wi-Fi password for the system, everything happens automatically, and it looks like it's working! Now I'll insert the card into the Raspberry, plug in the mouse and keyboard, and see how it all works!

After a few resets and obvious issues with setting up the display, the system booted up correctly!

After the Raspberry Pi has booted up correctly, you need to go through the standard configuration – setting the username and password, and entering the Wi-Fi password. For this reason, I’m a bit disappointed – it looked like the Raspberry Pi Imager program would “burn” the Wi-Fi password I use, but that didn’t happen. After a reset and logging in – everything works! In the embedded world, that’s not obvious – that’s why I’m happy!

The user interface is simple and clear, and I can see the option to launch communication buses and general system configuration – all through the graphical interface! In the next step, I’ll try to connect an air quality sensor to one of the interfaces and attempt to read basic parameters around the device

What did I want to do? I wanted to create a containerized environment with Yocto inside. I wanted to build an application for Raspberry Pi that would run Home Automation and to which I could connect sensors via some yet undefined protocol.

The simplest solution was to use a ready-made distribution — Raspberry Pi OS. However, it is not widely used in professional projects. I wanted to learn what appears most frequently in job offers and, at the same time, solve my engineering problem. So, I decided on Yocto.

The first few days I struggled with container-related problems, which, of course, I had created myself. Then, after verifying that everything worked without the container, I started focusing on the configuration and managed to create the first image to upload.

But here came another fundamental problem — I had never had the pleasure of playing with Raspberry Pi before. I know what UART is and how it works; I built an image that should contain a full console, connected the device to a USB adapter, inserted the card, and what happened? Nothing. Silence. What's going on? I have no clue!

A mountain must be conquered in stages! I’ll start simple — I’ll install Raspberry Pi OS. I will check if the UART console is enough to play with this system. If so, I will install a Home Automation server, try to connect the first sensor, and link it to my system.

What's next? I guess it’s time for Buildroot. I will try to do exactly the same but by creating my own image. Only after completing these two stages will I start working with Yocto. I’ve lost a lot of time and energy, but I think I’ve already learned a lot. In the next post, I will try to describe my interactions with this operating system.

What do I want to run on this Raspberry? For now, I have only one idea: Home Assistant. If you've never heard of it, let me explain. Home Assistant is a service to which I can connect multiple sensors, it has a graphical interface, and in this interface, I can create real magic. Let’s take a simple example of a smart socket and a temperature sensor with connectivity. We connect both elements to Home Assistant. We plug a heater into the socket, and we display the temperature sensor in our welcome interface. Let’s add a simple automation: if the temperature drops below 20 degrees – turn on the socket, if the temperature rises above 25 degrees – turn off the socket. In a simple way, we've turned an analog heater into a smart heating system for our room, and on top of that, we can check the temperature on our phone.

To be completely honest with you, I’ve never done anything more complicated with Home Assistant and sensors – and that’s one of the reasons I want to launch this project.

I will definitely want to run more services in the future, and they will all rely on one technology: containers. I fell in love with them as soon as I started writing them myself. Containers are a technology that builds a system out of blocks to run a specific functionality. For example: the Home Assistant server. To run it, I will need a Linux system, a few installed packages, and the server itself. I create a file where I specify what I need, I define a sequence of actions that I would have to perform manually on my computer anyway, and everything should work. Usually, this takes much more time than running such a server locally, but there is one major advantage to this solution – you describe everything in a single text file, just a few lines. You run the same file on another computer, on a different operating system, and everything works.

This is the only technology where you can’t throw "it works on my machine" in your colleague’s face. Of course, there are exceptions, which I plan to describe in the future, but with a well-described container, the operating system on which you run it doesn’t matter.

The life of an engineer is not the most exciting, and it never seemed to me that it was something worth sharing with the world. However, recent changes have made periodic reflection on my engineering endeavors feel necessary.

Since the beginning of February, I have embarked on my journey as a freelancer. I created this website, set up profiles on the most popular freelancing platforms, and mentally prepared myself. As a freelancer, I am not only my own captain but also the ship, the helmsman, and the deckhand. In a project company, there are many expert-islands – people you interact with daily, who help you bounce ideas off them. Often, a simple conversation over coffee, where you explain your challenges to a colleague, helps untangle a problem. A well-known concept in the engineering community: the rubber duck debugging method.

On a one-person ship, there is no one to bounce ideas off. You have to motivate yourself to explain your problems. And what better way to do this than through writing? Writing requires attention, careful word choice, and the ability to condense complex issues into simple sentences that are understandable to a less technical audience. That’s how I ended up here, writing a blog. I intend to occasionally describe the problems I face, share my freelancing journey, and organize the noise in my head.