• Why Migrate
  • Home Assistant
    • Installation on TrueNAS
    • Migration
    • Troubleshooting
  • Tandoor
    • Easy migration, and PWA instead of 3rd party app
  • Nextcloud

Why Migrate

I described my old server setup briefly in this post but here’s a brief excerpt from that post:

My dad had an old Acer Aspire XC-886 desktop lying around with a 9th-gen i3 CPU, which I ended up using for the server. I bought two 1TB SSDs and installed Ubuntu Server 22.04 on the desktop. I used mdadm to create a RAID 1 array over the two SSDs for redundancy.

I installed Nextcloud to back up all of the videos and photos from the hard drive. I chose Nextcloud because it did what I needed (and more), seemed easy to install, and offered Office-like capabilities I thought I might use later. Eventually, I bought a domain, got a static IP from my ISP, and made the service available to my family.

As time went on, I wanted to run more software on the Acer server. I tried running Pi-hole (but DNS is a pain, so I ditched that) and ended up running Home Assistant instead. This is my latest post on that journey at the time of writing.

So that was my setup before building the new server: an old Acer desktop running Home Assistant and Nextcloud, with ports forwarded for remote access.

I wanted to have everything “under one roof”, more or less. While I am ok running extra infrastructure, such as a proxy manager or geofencing, on other hardware, I wanted all of my services running on one server, preferably using the same technology (namely Docker in the form of TrueNAS Apps). This would, in theory, make backups easier, and general system administration.

I had 3 services running on my old server: Home Assistant, Tandoor, and Nextcloud. I will be covering each migration in increasing difficulty.

Home Assistant

My old Home Assistant setup consisted of a Docker Compose file along with a mounted volume in /opt/homeassistant/. a setup copied from a blog I unfortunately don’t remember the name of.

version: '3'
services:
  homeassistant:
    container_name: homeassistant
    image: "ghcr.io/home-assistant/home-assistant:stable"
    volumes:
      - /opt/homeassistant/config:/config
      - /etc/localtime:/etc/localtime:ro
    restart: unless-stopped
    privileged: true
    network_mode: host
    ports:
      - "8123:8123"
    environment:
      - DISABLE_JEMALLOC=1

This install has been relatively unproblematic, and when I plugged in my Zigbee dongle it ‘just worked’. I specifically used the ZBDongle-E model from Sonoff.

Given that this ‘just works’ setup was based on Docker, and I wanted to move it to a Docker container in TrueNAS it should be easy right? To my surprise it actually was.

Installation on TrueNAS

I created the following datasets in TrueNAS using the App preset in the dataset creation wizard. In the Home Assistant configuration wizard I set all storage options to use a host path, and pointed each host path to the corresponding dataset. The only extra option which had to be set was the “Automatic Permissions” option. Other than that, my Home Assistant instance was up and running without too much hassle.

Migration

I created a backup on my original Home Assistant instance, downloaded it to my PC, and in the new instance I chose the “restore” option on the welcome page. It was almost that easy…

Troubleshooting

My ZigBee integration simply would not work. All configuration was imported correctly, but it seemed that Home Assistant could not connect to the device.

My first troubleshooting step was to check that the container could actually see the device, which was confirmed with lsusb.

After digging around in the terminal for a while I went back into the Home Assistant config, and found the “device” section of the config page. It turns out that I needed to map my device to the container, in order for it to use it. This was something I had not considered since lsusb showed the device from a shell in the container.

Tandoor

I had installed Tandoor using Docker Compose on the old server. TrueNAS doesn’t directly support Tandoor, and for now I don’t want to install community supported apps.

Researching self-hosted recipe software can be bewildering, but I ended up using Mealie instead.

Easy migration, and PWA instead of 3rd party app

Migrating from Tandoor to Mealie is rather easy and intuitive, and installing the PWA is just as easy. Good thing Apple reversed their decision about PWAs in the EU.

Nextcloud

…

I haven’t migrated Nextcloud yet.

Last summer, I bought an expensive camera since the one I inherited from my grandfather was starting to show its age (a Canon EOS 400D DSLR). So, I upgraded to a Canon EOS RP instead.

Fast forward half a year, and I’m getting the hang of this camera. I want to showcase my photographs beyond just posting them on Instagram. I already have a domain, and Adobe Portfolio is included in my Creative Cloud subscription, so I figured I might as well use it to host my “portfolio”. Now, I just need a landing page to link to both my blog and my portfolio.

Table of Contents

• My Landing Page and Overall Setup
  • I Have No Idea How to Write JavaScript
  • My Overall Setup for My Personal Sites
• Why I’m Not Scared That LLMs Will Take Our Jobs Anytime Soon

My Landing Page and Overall Setup

The image above is a screenshot of my landing page at the time of writing. It consists of a split view, with one image in each section, overlaid with text. When the mouse is not hovering over an image, the saturation and brightness are reduced. When hovered over, the images animate to remove these effects and zoom in slightly. The split orientation depends on the aspect ratio of the window, meaning that the page will split horizontally on phone screens. The “Blog” image links to blog.anders-lauridsen.dk, while the “Photos” image links to photos.anders-lauridsen.dk.

The landing page is written in JavaScript, and I should mention that I had never written any JavaScript before this. I’m still not entirely sure about some of the specifics I used for this project.

I Have No Idea How to Write JavaScript

So why did I choose JavaScript?

Before creating the landing page, I wanted to explore my hosting options, as I didn’t want to self-host it. After some research, I decided on Vercel because of its attractive free tier for website hosting. It also happens that Vercel is the company behind Next.js, so it made sense to use their own framework for my landing page.

I set up a GitHub repo, opened up ChatGPT, and got to work. I actually struggled quite a bit, which I’ll touch on later in this post.

My Overall Setup for My Personal Sites

Right now, I have three websites under the domain anders-lauridsen.dk: my landing page, my blog, and my portfolio. My blog is still hosted on GitHub Pages, as I described in this post. My portfolio is hosted on Adobe’s servers and created using their Adobe Portfolio tool. My landing page, as mentioned earlier, is hosted on Vercel.

Setting up HTTPS with GitHub was a bit of a hassle, as their system is very particular about DNS configurations. However, I’m happy that my entire setup is free (aside from my Adobe subscription and domain registration) and doesn’t require me to host anything myself.

Why I’m Not Scared That LLMs Will Take Our Jobs Anytime Soon

ChatGPT did a job of creating the website as I described (notice I didn’t say a good job). Unfortunately, I didn’t save my chat history, but suffice it to say that my first prompt got me 95% of the way there. The rest of my tokens were spent trying to get it to fix an error in its own code. Since I was using screenshots to debug, I couldn’t continue the conversation after running out of free tokens—I would’ve had to start a new chat with another model.

Instead of opening a new ChatGPT chat, I decided to test Gemini from Google to see if it could fix ChatGPT’s blunders. I spent about an hour trying, but to no avail. In the end, I resorted to the old-fashioned method: actually reading the code on my screen.

The code responsible for creating the image, text, link, and animation is within this div below:

<div className="relative h-full w-full">
    <Image
    src="/IMG_0141.jpg"
    alt="Blog Image"
    fill
    priority
    sizes={isVerticalSplit ? "50vw" : "50vh"}
    className="object-cover transition-transform duration-500 filter grayscale-[30%] brightness-[50%] group-hover:grayscale-0 group-hover:brightness-100 group-hover:scale-110"
    />
    <div className="absolute inset-0 flex flex-col items-center justify-center bg-opacity-30">
    <span className="text-white text-4xl font-bold mb-2">Blog</span>
    </div>
</div>
</a>
<a
href="https://photos.anders-lauridsen.dk"
className={`relative overflow-hidden group ${
    isVerticalSplit ? "w-1/2 h-full" : "w-full h-1/2"
}`}
>

The problematic part of the code was in this line:

<Image
src="/IMG_0141.jpg"
alt="Blog Image"
fill
priority
sizes={isVerticalSplit ? "50vw" : "50vh"}
className="object-cover transition-transform duration-500 filter grayscale-[30%] brightness-[50%] group-hover:grayscale-0 group-hover:brightness-100 group-hover:scale-110"
/>

ChatGPT had included the bg-black style in the className of this <Image> tag. I hadn’t noticed this at first (and even if I had, I wouldn’t have known it was an issue, since I’ve never done frontend development before). Gemini didn’t catch it either. After about 10 minutes of reading through the code, I finally spotted it and removed it—solving all my issues (at least with my landing page).

So why am I not scared that LLMs will take our jobs anytime soon? Because, honestly, they’re still quite dumb (sort of). Modern LLMs are amazing tools that allow people like me to create a landing page in an afternoon, even with no prior JavaScript experience. They can serve as a useful sounding board and work well for rubber-duck debugging. But as much as tech bros and AI influencers like to call LLMs “AI,” they still lack the “intelligence” part of artificial intelligence. Predicting tokens is no substitute for critical thinking and actual experience—it’s just a neat productivity booster (and does a decent job of proofreading blog posts).

Maybe I’ll be proven wrong within the next five years when AI has taken 90% of tech jobs and Teslas have actual self-driving. But I doubt it.

Flash forward a couple of years, and I’m visiting my parents. They pull out an old hard drive enclosure so we can watch some old pictures and home videos from vacations and such. It’s a great time. When we’re done, I ask how old the enclosure is and whether they keep any backups. The hard drive in the enclosure is from 2006, and no, they do not keep any backups. So that’s 40GB of childhood memories stored in an enclosure that could fail at any moment. That was when I decided I needed to back it up somehow. And that’s why I built my first home server.

Table of Contents

• The Old Setup
• The New Setup
  • Choice of Software
  • Hardware
  • Putting it all Together
• Conclusion

The Old Setup

My dad had an old Acer Aspire XC-886 desktop lying around with a 9th-gen i3 CPU, which I ended up using for the server. I bought two 1TB SSDs and installed Ubuntu Server 22.04 on the desktop. I used mdadm to create a RAID 1 array over the two SSDs for redundancy.

I installed Nextcloud to back up all of the videos and photos from the hard drive. I chose Nextcloud because it did what I needed (and more), seemed easy to install, and offered Office-like capabilities I thought I might use later. Eventually, I bought a domain, got a static IP from my ISP, and made the service available to my family.

As time went on, I wanted to run more software on the Acer server. I tried running Pi-hole (but DNS is a pain, so I ditched that) and ended up running Home Assistant instead. This is my latest post on that journey at the time of writing.

So that was my setup before building the new server: an old Acer desktop running Home Assistant and Nextcloud, with ports forwarded for remote access.

The New Setup

I got a Raspberry Pi 5 for my birthday and started tinkering with homelabbing again. I knew I wanted to run more services locally, such as Jellyfin, and I wanted a “proper” server to do so—”proper” meaning a dedicated build. I also wanted an easier and more reliable way to back up my data remotely, which felt clunky given that I had installed Nextcloud using Snap and intended to run everything else through Docker Compose.

Choice of Software

I created a list of the services I wanted to host:

• Home Assistant
• Nextcloud
• Jellyfin
• One or more SMB shares with plenty of space for my Canon camera photos

Around this time, I heard about HexOS, a paid software built on TrueNAS Scale, which supposedly makes it easier to use TrueNAS. Even if I didn’t end up using HexOS, I could always fall back to TrueNAS, and I liked the project, so I decided to support them by buying a license.

Hardware

With the software plan in place, I needed hardware to match these requirements:

• Plenty of hard drive bays
• Enough CPU power for seamless movie streaming while running all my services
• Ample RAM for caching files (TrueNAS Scale uses ZFS, which benefits from extra RAM)
• A case that wouldn’t make my living room look like a server room

Here’s what I bought:

I still need to buy some Noctua fans for the hard drive bay, as the included ones are quite loud.

Putting it all Together

Building the system was great fun, though I wouldn’t recommend assembling in the Jonsbo case without prior experience. I built the SSD, motherboard, CPU, and RAM outside the case, added a GPU for video output, and installed the OS. I later realized that using a laptop with a replaceable SSD would have made installation easier.

HexOS lived up to its branding—it was easy to install and set up an SMB share. However, many supported apps still require configuration through the TrueNAS dashboard. Despite that, I do recommend HexOS for quickly turning an old PC into a NAS.

Right now, my setup is a bit scattered, but I plan to consolidate everything onto the HexOS system. Currently, I have:

• Raspberry Pi 5: Runs Nginx Proxy Manager for handling SSL certificates and routing traffic.
• Acer Server: Runs Home Assistant, Nextcloud, and Tandoor. I plan to migrate these services to HexOS and repurpose the SSDs.
• HexOS Server: Runs FreshRSS, Flame, Jellyfin, qBittorrent, Unifi Controller, MeTube, and SMB shares.

One limitation is that HexOS only allows expanding storage pools with three or more drives, meaning I’ll need to buy three new HDDs before expanding storage.

Conclusion

It might have been wiser to buy a motherboard with 2.5Gb Ethernet, and had I known about the storage pool expansion limitation, I would have bought another drive upfront. Otherwise, I’m very proud of the system.

My homelab setup is still somewhat janky, with three different installation methods (Snap, Docker in TrueNAS, and Docker Compose on Ubuntu) across three systems. However, it has the potential to become a solid setup.

There’s still a lot of work to do—migrating services, upgrading hardware, and setting up proper backups—but it’s been reliable these past few weeks, and best of all, it requires NO subscription fees!

Table of Contents

• Installing Rustup
• Dependencies
• Compiling Zellij

Installing Rustup

The recommended way of installing Rust on Linux is using Rustup. I ran the following command from the [Rust install site].

The recommended way to install Rust on Linux is via Rustup. You can use the following command from the official Rust installation site:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Choose the recommended settings during the installation process. This will set up Rust quickly and easily.

Dependencies

Trying to install Zellij without installing additional dependencies will result in errors. These are the dependencies I installed before Zellij would compile,

• gcc
• openssl
• rust-openssl-sys-devel
• perl which can all be installed with dnf.

The step which fails without these dependencies is when the Rust compiler tries to build openssl. In order to build openssl Perl is needed, so I suspect that you only need to run

sudo dnf install perl

However, if this does not work, you might want to try and install all the other dependencies. With that in place, you should be able to install Zellij.

Compiling Zellij

With Rust and the necessary dependencies installed, you can compile Zellij using Cargo. Follow the instructions from the official Zellij documentation:

cargo install --locked zellij

If you’ve installed the dependencies mentioned earlier, this command should execute without any errors.

Some details on the software side of things are skipped. This is where I am just following this guide from Andreas Skoglund closely. I do not want to just re-post what he has already written up, and I recommend supporting him on Ko-Fi if you find this guide useful.

Also big thanks to Nikolaj Krægpøth for helping out with this project. He saved a lot of time, and probably some headaches, in the electronics part of this project.

Table of Contents

• Software
  • Snapcast
    • First Setup
    • Daemonizing the Snapserver
  • Librespot
• The Speakers
  • Internals of the Speakers
  • Amplifiers and Sound
• Conclusion
  • Issues and Further Work

Software

My choice of software is very much dictated by the blog post from Andreas Skoglund, since I want to get a proof of concept up and running as soon as possible. I will for sure add more software to the stack in a future iteration of this project.

Snapcast

On the GitHub page of Snapcast they say that

Snapcast is a multiroom client-server audio player, where all clients are time synchronized with the server to play perfectly synced audio. It’s not a standalone player, but an extension that turns your existing audio player into a Sonos-like multiroom solution.

This is more or less exactly what I want in an audio setup. This section walks through how I set up my current configuration of Snapcast.

First Setup

Since Snapcast is distributed to Debian based systems, I could just download and install the packages from the release page.

After installing the correct packages I went and tested the setup. I have my Pi 5 and Pi 3A+ hooked up to the same network, and my headphones plugged into the AUX port of the Pi 3A+. After opening up a terminal on the Pi 3A+ I opened alsamixer to turn the volume, in order to not blow out the speakers of my headphones. I then ran the snapclient command to spawn the client, and logged into my Pi 5. On the Pi 5 I have tmux installed, and opened up a session. In the first window I started the server by running snapserver. I opened up a new window, and then ran cat /dev/urandom > /tmp/snapfifo. This should start playing white noise on the headphones plugged into the headphones.

The files /dev/random and /dev/urandom provide an interface to the random number generator in the Linux kernel, the difference between them being that the form the former will block reading if the system is not able to generate “random enough” numbers, and the latter will never be blocked. This is lifted from this post from the Linux Handbook.

When I first did this I ran into permission issues, since Snapcast creates a user and group for that user called snapserver, on the server. I had to change the ownership of the file using chown in order to test this in my case, but switched the owner back after testing.

Daemonizing the Snapserver

When I was first messing around with Snapcast I accidentally set some configuration options in one of the configuration files for snapserver. This led to me wasting at least an hour before figuring out why I could not start the server as a service.
With /etc/default/snapserver file on my Pi 5 which looks like this

# Start the server, used only by the init.d script
START_SNAPSERVER=true

# Additional command line options that will be passed to snapserver
# note that user/group should be configured in the init.d script or the systemd unit file
# For a list of available options, invoke "snapserver --help"
SNAPSERVER_OPTS=""

I was able to enable and start the server using systemctl as you would any other daemon.

To test this I downloaded a .wav file using wget, and added the following option under the [stream] tag in /etc/snapserver.conf on the Pi 5.

...
[stream]
stream = file:///opt/a2002011001-e02.wav?name=test
...

This allows me to go the the local ip of the Pi 5 on port 1780 in a browser, and see a web interface for Snapcast, with the clients listed on that site:

Note: I never actually enabled the client service on the Pi 3A+, but it seems that it is enabled, and works as it should. I did not have to set it up any further than that. I also do not remember how I pointed the client to the server’s IP, but if it works it works.

Librespot

I have written about Raspotify before in my post Smarthome Saga Part 1, and it does seem like the easiest way to get what I wanted up and running. I am however, still mostly following the blog post from Andreas Skoglund, and as such I will be installing Librespot as he recommends in his post.
The biggest difference in practice is that I had to compile the Rust code myself, instead of running the install script from Raspotify.

I did have to do one thing which was not mentioned in Andreas’ blog post. I had to install some extra dependencies (libasound2-dev, portaudio19-dev, build-essential, libpulse-dev, libdbus-1-dev) on my Pi 5. This was pointed out in this comment on GitHub.

After configuring the stream as he did, with my own username and password of course, it worked perfectly. I went in and commented out the only other stream (/tmp/snapfifo), and now the Pi 5 is listed on the network as a Spotify Connect device, which automatically casts the sound from spotify to all other devices.

The Speakers

The picture in the intro is the internals of one of my 2 VERY old Dali speakers. They seemed to be a good fit for this project because they were VERY cheap on Facebook Marketplace.

Internals of the Speakers

I took them apart to get an idea of how they were wired up. There are 2 cement resistors (white boxy things), which are also the only 2 components where the specs are known. The big yellow capacitor has some capacitance, and the inductors also have some inductance. I had hoped to get the exact values and derive the filter specifications on what is passed to the woofer and tweeter. This idea was scrapped when I couldn’t find these values.

Amplifiers and Sound

I bought a “TPA3116D2” amplifier of off AliExpress which in theory is way overspecced for this build. They take around 18V input, with a wide range of acceptable input voltages. It also takes the sound signal over 2 terminals. And of course it has an amplified output of some sort as well.

In order to power the amplifier I cut and stripped the wire of an old laptop charger which runs at 19V and 1.75A, which should be plenty to power the speakers.

In order to get sound to the amplifier I cut and stripped the wires of an old pair of crappy headphones, which connects to the Pi 3A+ over an AUX jack.

To get the sound to the speaker I used some old speaker cables I had lying around in the apartment.

The picture above shows the wiring of this system (the middle terminals are the power-in from the laptop charger). Between the audio-in and power-in terminals there is a potentiometer used to set the volume of the speakers. In a future iteration of this project I will find a maximum acceptable volume for the speakers, and “lock it in”, to remove the possibility of blowing out the speakers.

Conclusion

PoC could be short for proof of concept, or it could be short for piece of crap. Both of these acronyms are good descriptors for how this project turned out.

This PoC technically worked! I was able to find the Snapcast server on the Spotify Discover list. Playing music then casts the music from the Pi 5 to the Pi 3A+. This sound is then amplified using the AliExpress amplifier and sent to the speakers. I have to admit that I did a little dance and started dancing when the speaker played the song.

The sound quality of this PoC is not very good, and the wiring is horrendous.

Issues and Further Work

One big issue is that the signal quality is not all that great, and nothing is grounded. This results in a hissing and popping sound constantly playing on the speaker. As of now there is also no Home Assistant Integration.

I am not going to keep the system running, since I would lose my mind of that noise was constantly playing in my apartment. It is also not the nicest thing to look at in it’s current state. I am also not allowed to keep the Pi 3A+, unfortunately.

Next iteration of this project would be to install the Snapclient software on a few old Android phones, and ground the connection to remove the hissing noise. I would also like to move as much of the electronics into the body of the speakers as possible. If it is within scope I would also like to integrate the Snapcast system into Home Assistant.

All in all this project has been a success, since I accomplished the goals I set out, even though the PoC can best be described as “janky”.

Over the years since I have bought more lights, some Google smart speakers, and a smart TV (which is just a TV these days…). But I never really got into self-hosting smart solutions since then, until 2023 when I received a Raspberry Pi 5 for my birthday.

This blog-post details my first dive into self-hosting my smarthome, and my hope is that it will be one of many posts talking about setting up cool features, only really allowed by self-hosting. In this post I will talk about how I set up conditional reminders, and turned my VERY old speaker system into a “smart” speaker system by using the Spotify connect protocol.

Table of Contents

• 1. Hardware
  • Raspberry Pi 5
  • Ikea TRÅDFRI
  • Google Nest Mini
  • Old Speaker System
• 2. Software
  • Docker and Home Assistant
  • Raspotify
• 3. Conclusion

1. Hardware

Raspberry Pi 5

As mentioned before, I got a Raspberry Pi 5 my birthday in 2023, which has since served as the brains of my smarthome operations. The only additional hardware I have for the Pi is the Raspberry pi 5 case, the power supply, an SD card, and a USB-to-Aux cable.

In the future I would like to add the NVME hat which Jeff Geerling has an excellent blog post about, and a Z-wave USB controller. The Z-wave controller would be needed in order to not rely on the IKEA Tradfri hub, and other hubs from Z-wave device manufactures like Phillips.

Ikea TRÅDFRI

I have a few bulbs from the TRÅDFRI lineup from Ikea. All of them are hooked up to an Ikea TRÅDFRI Hub, using one of their remotes. My plan is to use the Z-wave controller in order to get rid of this hub, and these controllers, since they only really clutter my home.

If I wanted to add more Z-wave controlled devices in the future I would also like to not have 5 different hubs hooked up to ethernet and power all of the time.

Only one of these lights have died on me since I bought them. It was slightly over 3 years old, and the others (between 2 and 4 years old at this point) are still going strong.

Google Nest Mini

I have two of these small smart speakers, one of them I bought second hand, and the other I bought new. Their sound is decent, but my hope is that I would have these replaced with proper speakers in the future. I also find that the Google “smart” assistant is often the worst way to get anything accomplished.

I only really use it for conversions between imperial and real units when cooking, or perhaps setting alarms (which could just as well be done from my phone).

Old Speaker System

I don’t know which speakers I have right now, or which amp they are connected to. I do have plans for maybe opening up the amp to make it turn on when I connect to the Raspberry Pi. If I ever do that I will of course write down some details on what I’m using.

These old speakers really do sound great when a device is hooked up to the amplifier via Aux. I personally got them from a family member who did not have the space for them anymore, but similar speakers can be had on Facebook Marketplace for cheap.

2. Software

The software deployed so far has been rather plug and play, with only some slight configuration needing to be done. How my software is set up as of now will most likely change, maybe I will add Google Cast, maybe not.

Docker and Home Assistant

Docker is being used to host the Home Assistant, since native support for the Raspberry Pi 5 was added a few months after I set up my system…

Using Docker is not the worst thing every, since it does make porting easier, though I would like to experiment with installing it on the Pi directly, once I have another micro PC as the Pi Zero 2 W running Raspotify on the speaker system.

I used Docker-Compose to run the container, the guide I took inspiration from can be found here.

Here is my docker-compose.yaml

version: '3'
services:
  homeassistant:
    container_name: homeassistant
    image: "ghcr.io/home-assistant/home-assistant:stable"
    volumes:
      - /opt/homeassistant/config:/config
      - /etc/localtime:/etc/localtime:ro
    restart: unless-stopped
    privileged: true
    network_mode: host
    ports:
      - "8123:8123"
    environment:
      - DISABLE_JEMALLOC=1

I might move to installing the new native Home Assistant software on the Pi, but that would necessitate a new single board computer for running Raspotify. I have not been able to get Bluetooth working in the Docker container, so installing the OS is appealing.

So far the only automation I have set up is my Google Nest speakers reminding to air out the apartment a couple of times each day, if I am home. Though, I do intend to add more automations once I am working full time and have a more fixed daily schedule.

Raspotify

Raspotify is a wrapper around a Rust library, which allows it to function as a Spotify Connect receiver. It is technically for Debian 11, and Raspberry Pi OS is based on Debian 12, but the install script worked perfectly fine for me. If the script turned out to not work I don’t believe it would be too hard to Dockerize the application.

Setting up the software once it is installed was not all that difficult. The workflow consists mostly of

sudo nano /etc/raspotify/conf
systemctl restart raspotify

Knowing what needs to be changed can be gathered by looking at

journalctl -u raspotify.service -b

I didn’t write my steps down, and this is not a detailed guide, so I won’t provide the exact steps to reproduce this setup in this post, but my configuration can be found in the GitHub repo.

I also used the alsamixer CLI tool to turn up the volume on the Pi, in hopes that I would be able to go over a larger volume range once connected over Spotify. I don’t know how this is handled by Raspotify, and therefore I don’t know if it is worth replicating. But it is there as a troubleshooting step.

3. Conclusion

Running Home Assistant in Docker on a machine that is also connected to my old speaker setup over AUX seems like a “proof of concept” state of my smarthome. Given this I would like to invest in some more hardware, such as a Z-wave USB controller, and some Z-wave devices which aren’t just smart lights, such as blinds or electricity meters.

I am pretty happy with what my smarthome is so far. I am able to play music on my nice speaker system, without hassle, or spending a fortune on new smart speakers. I am also a fan of being able to create automations without relying on Google keeping functionality available for many years, since it would be a shame if they killed off Google Home after I spend several hours setting up automations in that framework.

I am looking forward to adding more devices to my ecosystem, and playing around with Home Assistant some more.

One such non-problem is knowing when microwave popcorn are done popping. I had the idea when I had some friends over for a visit, and we wanted popcorn. I didn’t want to leave the conversation, but I didn’t want to leave the conversation. And while waiting for the popcorn to pop I started to wonder how one might automate the process of determining the doneness of microwave popcorn. My thought process was that since instructions on popcorn boxes often tell you to check the time between pops, if I could detect the individual pops, the challenge of determining doneness would be trivial.

The code I wrote for this blog post, and the current state of the project, can be found at This GitHub Repo

Table of Contents

• 1. Exploration
• 2. My Naive Algorithm
• 3 Does the algorithm detect popcorn?
• 4 Does the algorithm work a second time?
• 5 Conclusion

1. Exploration

In order to test how I could detect individual pops, I needed to collect some data. This was done through a highly scientific process:

After collecting data I loaded the resulting mp3 file into Python, in order to get a sense of what the data might look like.

My phone seems to have recorded at $32,000Hz$, which allows us plenty of resolution in frequency to analyze the popping of popcorn. In the figures below we see the waveform that the phone recorded, and the spectrogram of that waveform.

Looking at the waveform we see quite a lot of noise from the microwave, which seems to be on the low end of the frequency spectrum, when looking at the spectrogram. We also see a big loss in energy at the top of the frequency range of the spectrogram, which I honestly can’t explain, other than my phone might not be able to pick up such high frequencies. From the spectrogram it looks as though the popcorn might be visible as vertical lines on the spectrogram, meaning the individual pops are quite broad spectrum. So in designing the algorithm which is going to detect pops we assume two things for now:

1. The pops are more or less uniform in the frequency range of $2000Hz$ to $10,000Hz$.
2. The energy of the noise produced by the microwave is mostly of frequencies lower than $4000Hz$.

Using this let’s create a band pass filter using Scipy, and set the critical frequencies to $f_{c1}=4000Hz$ and $f_{c2}=10,000Hz$. Filtering a signal according to a Butterworth band pass filter can easily be achieved by the following code.

x, sr = audio2numpy.audio_from_file("popcorn.mp3")
x /= np.max(np.abs(x))  # Normalize the recorded waveform
t = np.arange(0, len(x)) / sr

a = signal.butter(5, [4000, 10000], btype="band", fs=sr, output="sos")
y = signal.sosfiltfilt(a, x)

After filtering we can see on the waveform in the figure below that most of the noise of the microwave has been removed.

And now that we have removed much of the noise, we can zoom in on one single pop, and see what shape a pop takes in time (since we already “know” they are pulses which are uniform in frequency). Looking at the next figure we see that an impulse that decays exponentially. What is mostly of interest for this first implementation of a popcorn detector is the decay time, which from the plot below seems to be about 0.1 seconds. The exponentially decaying nature of the absolute waveform might be of interest in a more robust algorithm.

2. My Naive Algorithm

While using the shape of the shape of the waveform of a popcorn popping might be good for detecting individual pops, it seemed like a lot of work, so I chose to go with a more naive algorithm for now.

I chose to use the uniformity of the spectrum of a popcorn pop, and came up with the following algorithm:

1. Calculate the STFT $X$ of the signal $x$.
2. Iterate through the time slices of $X$
   1. Check the mean value $\mu$ of the frequencies of $X$ which are between $f_{c1}$ and $f_{c2}$
   2. Calculate \(\lambda=\sum_{f_{c1}< \omega < f_{c2}} |\mu - X_\omega(t) |^2\) for all the given time iteration $t$
   3. If $\lambda$ is larger than some threshold $\lambda_0$ then we call that a pop, and we skip the next iterations, corresponding to 0.1 seconds (this value is gained from the approximate time it takes a popcorn kernel to pop).
3. Calculate the time between each pop, and see if we are getting close to the value the manufacture specifies is the correct time between pops.

While this algorithm might seem ingenious and perfect, it does have some flaws that one might point out, even before testing it at all:

1. You have to know what value to set for $\lambda_0$.
2. The tool has no way of distinguishing between popcorn pops and perfect silence.
3. It might be slightly ineffective to carry out this many sums of squares calculations each second.
4. The algorithm doesn’t allow for multiple pops to occur within a time-span of 0.1 seconds.

Do note that a plus of this algorithm is that we do not need to filter the signal, since we only consider the frequency range where we have assumed that no microwave noise is negligible.

Hence, the title of this section. But no matter, let’s see how this algorithm performs after tweaking the $\lambda_0$ parameter.

3 Does the algorithm detect popcorn?

By seeing what values $\lambda$ had for times when no popcorn were popping it seemed that $\lambda_0=4\cdot10^{-5}$ was a good value. This would remove most of the false positives induced by the noise in the signal, while still allowing relatively silent pops to be caught by the algorithm. I also cut the first 62 seconds of the signal for this test, since this is when the popcorn started popping.

Looking at the figure below, we see a wide angle view of when the individual pops where detected. By looking at the amount of red dots centered around the more busy parts of the signals, this seems to be a decent algorithm.

It is however not easy to make out individual pops this way, so I zoomed in on a part of the signal which highlights that this algorithm seems to work fine under the conditions of this test.

Looking at the figure above we see that the algorithm actually gets decent performance on this part of the signal. Scanning across the waveform it looks like the algorithm catches most of the pops which occur. And looking at the resulting time between pops, it does look promising.

Seeing that taking a moving average with a window-size of 5 creates results that look like the one above, one might be tempted to slap this algorithm onto a microcomputer, wire it up to a microwave, and create a Kickstarter with a silly name. But this is a blog of science, so I did actually do more than one test on this algorithm.

4 Does the algorithm work a second time?

I used the exact same code as I did in the previous test, but changed the microwave and the brand of popcorn. Ideally I would’ve also used a different method of recording, but that might be covered in an improved popcorn detection algorithm.

Above is a wide view of the detections in the second test. I was happy and surprised to see that the algorithm seemed to have worked. I had expected the algorithm to either detect basically no popcorn, or to have a lot of false positives. Zooming in we see that there seem to be no false positives, but some pops are not detected.

One would expect the algorithm to call the popcorn done before they were actually done, given that some pops were not detected. But even though that the time between pops is calculated to be higher than what it actually is, we still ended up getting popcorn that had been in the microwave for too long.

Above we see the smoothed time between pops, and it never even reached 2 seconds. Even when not smoothing the time between pops, the time never got higher than 1.6 seconds. This means that if we had only used the algorithm to evaluate the doneness of the popcorn, We would’ve burned the popcorn.

5 Conclusion

Much to my surprise, the algorithm seemed to have worked, to some extent. The detection of individual pops works quite well, even though it does miss some pops. If we were to use this detection method, along with the instructions on popcorn packages that say to wait until pops are 2 to 3 seconds apart, we would burn our popcorn. So I need a new way of evaluating when the popcorn are done, if I wanted to keep using this method of detection.

I might continue on this project, and change/improve some things. Among these are

1. I want to use a new way of detecting, namely matched filtering which seems interesting to learn about.
2. I want to use the PyAudio library to stream the audio to a Python script, so I can evaluate the performance of my algorithm by actually using it to create popcorn.

1. My old website

This is not the first iteration of my personal website. Back in December 2020 I decided to create my own personal website. My idea was to have a place to showcase whatever projects I had worked on, and perhaps for general blogging (I later realized that a 2nd semester project about Eigenfaces wouldn’t exactly be the most appealing project on my site…).
Even so I decided to continue to work on my site, by finding and buying a template that I liked, in order to get up and running quickly. I created a somewhat decent website if I do say so myself. If you’re interested you can check out the history of commits on the repository, though the naming of the earlier commits aren’t always the most useful. Though, some idea of what the website looked like can be gleamed from the images below.

While I was, and am still, happy with how the website looked, it was difficult to change the look of the website. Since I understood none of the tools that went in to creating the first website, I had trouble changing the contents of the site (specifically adding a blog-post functionality). Instead, I was stuck with this look on the site which does not lend itself to the blogging format.

My contact page also used a third party service, and was not really practical, so I wanted to scrap that as well.

2. My new website

As you can see the new website is drastically different from the old one. The old website functioned as a sort of online resume, more than anything else. I generally dislike having to write resumes, so having to write two when applying for a job, or when they need updating, seemed excessively meaningless.

2.1. Idea for the new site

I want to work on smaller projects, as I have done for the last couple of years, but in a more structured manner. I wanted somewhere to showcase these projects, and a personal blog seemed like the perfect way to do it.

My hope is that this blog will grow with interesting subjects over time, regarding mathematics, data-analysis, home-automation, and more.

2.2. Technology behind the site

I host the page on GitHub Pages, since I don’t need anything dynamic, and it’s free to host a site there.

I searched the internet and Jekyll Seemed like a good choice to build the website in, so I decided to go with that, since it can build static HTML sites from Markdown, which makes my life easier.

I started out by following this guide, which worked fine in the beginning. I did have some trouble getting a TeX engine (used for creating equations like this $E=mc^2$) working both locally and on the GitHub’s build system. After scouring the internet for solutions that worked either on GitHub or locally, I decided to find a template that had Mathjax properly configured from the get-go. And so I ended up going with Lagrange, a beautiful and easy to set up template.

Both the guide on GitHub and the guide included in the Lagrange repository are great to get started, and I highly recommend those guides if you want to build you own GitHub Pages site.