This guide is for people who have:

• An ikea matter device https://www.ikea.com/global/en/newsroom/retail/the-new-smart-home-from-ikea-matter-compatible-251106/
• NO hub, as they’re almost $70 USD
• An ESP32-C6 or ESP32-H2 [I used ESP32-C6 Xiao(https://wiki.seeedstudio.com/xiao_esp32c6_getting_started/)
• An already working home assistant

The confusing nature of matter,thread,hubs, openrouter etc is very confusing.

We will be turning our ESP into a Thread Border Router which allows us to connect devices to our home assistant.

Thread/Matter are a little confusing so all you need to know is:

• Matter is the protocol, e.g. “HTTP”, “MQTT”,”gRPC”
• Thread is the connection, e.g. “WiFi”, “Bluetooth”, “Zigbee”

The ikea devices, or at least the one I’m using, cannot use WiFi, only Thread, so the use of a “hub” is required.

This guide is a re-iteration of this post: LINK HERE, with the reason I’m making this, as I had no idea I wanted a “Thread Border Router”

For me, the distrobox method on the link above didn’t work due to permission issues, so I did it on my host OS (arch). If are not on Arch, I highly recommend using the distrobox version above, if you have permission issues (in the flashing step) try this instead.

sudo usermod -aG dialout $USER # Will probably fail, as arch uses the next command 
sudo usermod -aG uucp $USER

LOGOUT PLEASE LOGOUT

Read above, then do it, then come back. I promise it’s necessary.

If you logout and type groups and you see uucp or dialout, you’re good to go.

Must be on a python version above 3.8, 3.9 worked for me.

sudo pacman -S git python python-pip libusb cmake base-devel
mkdir -p ~/projects/esp-thread # can change 
cd ~/projects/esp-thread
rm -rf cheap-esp-tbr && mkdir cheap-esp-tbr && cd cheap-esp-tbr
git clone -b v6.0-beta1 --recursive https://github.com/espressif/esp-idf.git .
./install.sh esp32-c6
source ./export.sh
cd examples/openthread/ot_rcp
export LC_ALL=C.UTF-8 TERM=xterm

If you are using an ESP32-C6:

idf.py set-target esp32c6

If you are using an ESP32-H2:

idf.py set-target esp32h2

Menu configuration

idf.py menuconfig 

Navigate to:

• Component config —>
  • OpenThread —>
    • Thread Core Feautures —>
      • Thread Radio Co-Processor Feature —>
        • The RCP transport type —>
          • Select “USB” Save and quit via: s,esc,q ( save if prompted)

(Click below to expand)

vi main/esp_ot_rcp.c

/*
 * SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: CC0-1.0
 *
 * OpenThread Radio Co-Processor (RCP) Example
 *
 * This example code is in the Public Domain (or CC0-1.0 licensed, at your option.)
 *
 * Unless required by applicable law or agreed to in writing, this
 * software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied.
 */

#include <stdio.h>
#include <unistd.h>

#include "esp_event.h"
#include "nvs_flash.h"
#include "esp_openthread.h"
#include "esp_ot_config.h"
#include "esp_vfs_eventfd.h"

#if CONFIG_ESP_COEX_EXTERNAL_COEXIST_ENABLE
#include "ot_examples_common.h"
#endif

#if !SOC_IEEE802154_SUPPORTED
#error "RCP is only supported for the SoCs which have IEEE 802.15.4 module"
#endif

#define TAG "ot_esp_rcp"

#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

static void xiao_select_external_antenna(void)
{
    gpio_set_direction(GPIO_NUM_3, GPIO_MODE_OUTPUT);
    gpio_set_level(GPIO_NUM_3, 0);
    vTaskDelay(pdMS_TO_TICKS(100));
    gpio_set_direction(GPIO_NUM_14, GPIO_MODE_OUTPUT);
    gpio_set_level(GPIO_NUM_14, 1);
}

extern void otAppNcpInit(otInstance *instance);

void app_main(void)
{
    xiao_select_external_antenna();

    // Used eventfds:
    // * ot task queue
    // * radio driver
    esp_vfs_eventfd_config_t eventfd_config = {
        .max_fds = 2,
    };

    ESP_ERROR_CHECK(nvs_flash_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    ESP_ERROR_CHECK(esp_vfs_eventfd_register(&eventfd_config));

#if CONFIG_ESP_COEX_EXTERNAL_COEXIST_ENABLE
    ot_external_coexist_init();
#endif

    static esp_openthread_platform_config_t config = {
        .radio_config = ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG(),
        .host_config = ESP_OPENTHREAD_DEFAULT_HOST_CONFIG(),
        .port_config = ESP_OPENTHREAD_DEFAULT_PORT_CONFIG(),
    };

    ESP_ERROR_CHECK(esp_openthread_start(&config));
}

Flashing

Plugin your esp32, I personally held down boot as I plugged it in to ensure it went into flashing mode. ( Tiny B button) Verify your device is there via:

ls /dev/ttyUSB*  # or /dev/ttyACM* 

If the above command has nothing, try ls /dev/tty* and see if you have anything that isn’t /dev/ttyX or /dev/ttySX where X is a number

Then flash it via:

idf.py build flash

If you’re having permissions issues, try to verify your group via groups and if you’re not in uucp or dialout, re-run the commands at the start, logout, then try again.

Connect to Home Assistant

You need to plug the ESP32 into your home assistant box, via USB. If you’re using a VM, pass through the device, I’m using a TruenasVM my settings were as follows:

Restart your VM if you’re in one, then if you’ve installed any other Open Thread Border, Thread Border Router or Matter integrations, remove them. ( Assuming they’re not already being used)

Install the addon from This link

Before you start it:

• Go to configuration, and set the device to the /dev/serial/by-id/usb-Espressif…. option, NOT the /dev/ttyAMA option
• Disable Hardware Flow Control

Start the addon.

Now you’ll need your mobile device, and to follow step three HERE

After this, restart your home assistant app, and follow the steps HERE

If you’re having issues, try the following steps:

• Verify that the flashing worked, and you didn’t get an error during flashing earlier
• You’re on a python version above 3.8
• You’ve restarted your app, and done step 3 here
• Make sure you’re on your local wifi with no Tailscale, VPN, etc

Otherwise, you should have your device working! If you have any issues, please feel free to contact me and I’ll be more than happy to help.

If you regularly use man you’ll read this post and thing I’m an idiot, but I suspect I’m not the only one with a shallow understanding of what they use.

I’ve used Linux for what is considered a short period of time, though for me, it’s 28% of my life.

More like 50% if we’re counting the time I was actually conscious.

I’m sure at some point you’ve ran tree, possibly many many times, but how many times have you used more than just tree?

I’ve never explored past the basic tree until today, when I was trying to add my project structure to my README.md when I finally ran tree --help

My project, ‘AniSim’ a comparison site for users to compare their anime watch-history to others, has a beautiful node_modules, so throwing in a tree resulted in:

tree | wc -l

1631 lines…

The resulting tree --help was, a beautiful block of text that I’d consider, mildy overwhelming.

Not sure if I really need to use tree -acdfhjilnpqrstuvxACDFJQNSUX, I think something has probably gone wrong if I ever do.

So I’ll hanker-down to what I deem interesting to learn about, and you probably didn’t know.

The main two

1. Ignore with -I

Using

tree -I node_modules

will exclude node_modules, which is fairly nice outputting:

anisim main ? ❯ tree -I node_modules
.
├── cmd
│   └── anisim
│       └── main.go
├── docker-compose.yml
├── go.mod
├── go.sum
├── internal
│   ├── analyzer
│   │   ├── analyzer.go
│   │   └── analyzer_types.go
.....
├── tmp
│   ├── build-errors.log
│   └── main

But I have an issue here,

└── tmp
    ├── build-errors.log
    └── main

23 directories, 45 files

I don’t want my tmp files.

2. Gitignore with –gitignore

It does what it says on the tin, which is what most people will ever need.

tree --gitignore

For 99% of what I’ll ever need, this is perfect. But If I’m this ignorant about a command I’ve used 100’s of times, where else is there?

tree -L N (Level)

This limits the depth of the tree output, 1 being just the current directory, 2 being current + 1 subdirectory etc.

anisim main ? ✗ tree -L 1
.
├── cmd
├── docker-compose.yml
├── go.mod
├── go.sum
├── internal
....
9 directories, 10 files

tree –fromfile

This essentially performs a tree but only from a file, so if we use stdin for this I can list all of the .go files in my directory

anisim main ? ❯ find . -name "*.go" | tree --fromfile
.
└── .
    ├── cmd
    │   └── anisim
    │       └── main.go
    ├── internal
    │   ├── analyzer
    │   │   ├── analyzer.go
    │   │   └── analyzer_types.go
    │   ├── anilist
    │   │   ├── anilist.go
    │   │   └── recommendation
    │   │       └── recommendation.go

tree -t ( Sort by time)

This lists files sorted by time, which is fairly useful for seeing what you’ve changed recently. Combining this withh -L2, –gitignore and -D for the time modified, we get:

anisim main ? ✗ tree -t -L 2 --gitignore -D                                                                                                                                                                 
[Jan 21 14:07]  .
├── [Jan 17 17:32]  cmd
│   └── [Jan 17 18:21]  anisim
├── [Jan 17 18:07]  tailwind.config.js
├── [Jan 17 18:08]  package.json
├── [Jan 17 18:08]  static
│   └── [Jan 17 18:40]  css
.....

tree –inodes (Filthy pirate)

Some of you, like me, will know what an inode is, and some of you, like me, will only know what this is, as you’re trying to figure out, if your Radarr, Sonarr, Lidarr setup is correctly hardlinking files to save beautiful hard-drive space.

Now this is a terrible way of doing it, but doing tree –inodes in your Shows/Movies folder and once in your /Downloads folder will show the inode #. e.g.:

/Downloads
└── [   8916]  XXXX.mkv
/Shows
├── [   8916]  XXXX-Different name.mkv

Realistically if you were doing this, you’d do something like:

…/Record of Ragnarok 2021/Season 3 ❯ stat XXXX.mkv
  File: XXXX.mkv
  Size: Alot Blocks: More than 1 IO Block: 1048576 regular file
Device: 0,116	Inode: 8916        Links: 2 
Access: (0666/-rw-rw-rw-)  Uid: (  568/ UNKNOWN)   Gid: (  568/ UNKNOWN)
Access: 2025-12-23 14:13:57.561329090 +0000
Modify: 2025-12-23 14:17:42.192496523 +0000
Change: 2025-12-23 14:18:02.220778933 +0000
 Birth: 2025-12-23 14:13:57.561329090 +0000

Device: 0,116	Inode: 8916        Links: 2 

This line is what you’re looking for, but hey, not everyone is a filthy pirate.

Anyway, that’s enough typing, hopefully you learned something, and I’m going to work on learning the actual tools I use, as it’s very easy to take constant shortcuts, only for them to slow you down over time.

Open up https://account.proton.me/u/1/mail/filters

Open console etc, then run:

document.querySelectorAll('.toggle-container--checked').forEach(el => el.click());

Always be careful when running scripts, especially when running them from some random persons website….

alias ocr="wl-paste --type image/png | tesseract stdin stdout | wl-copy"

Occasionally I find myself within the maze of navigating the “world wide web” and trying to do something simple.

Ever tried to generate a QR code and realized the link is not to your domain, but to the QR’s generated site, so tracking and ads can be implemented ?

Or tried to convert a PDF and stumbled upon the dreaded adobe domain?

Anyway, I’m getting off topic.

I’ve had this same issue with OCR, so simply put, I created an alias that OCR’s the image in my clipboard, and copies said result back into clipboard.

Install tesseract-ocr and if asked about the data, aur etc, install the -eng version.

Add your alias, and voila, you can now copy an image, run ocr in your terminal, and paste the text anywhere you want.

Today I set myself a simple task, create a tool where I can find old commands. Primarily because I can never remember if it’s:

curl 'https://api.ipify.org?format=json

or

curl 'https://ipify.org/api?format=json

So I figured why not make a tool to not forget.

It’s written in rust(btw) and uses ratatui and clap.

The process is:

• Take input command
• Search bash / zsh history
• Search for any matches
• Allow for searching
• Upon selection, run the command :)

I’m sure I can use autocomplete, but I figured it’d be a nice opportunity to use ratatui.

My only critique of ratatui is having main branch examples not being the cargo version.It’s mildly annoying.

I’ve had this problem with esp-idf before, where I was using X.XX.B and the branch was X.XX.A. Skill issue I guess.

Anyway, it’s on the AUR/Cargo, you can install it via:

cargo install ifff

or

yay -S iff

Lastly, if you’re wondering what iff stands for, it’s “I fucking forgot”. Because.. I’m a child

See typewriters, they’re to most, not cool.

But Camcorders ? Walkmans ? iPods? They’re in the correct threshold for “cool” (for me)

To me? Thermal printers are cool. Eventually they won’t be, but for now? Cool.

I recently bought one of these: https://learn.adafruit.com/mini-thermal-receipt-printer

I had the bright idea of making messages print from my website.

Not this website, the top level of this site, willx86.com

Only accessible via SSH, I felt like it was the right place to put it.

Try it :)

ssh willx86.com

You’ll be prompted with a very intelligent question:

After the objectively correct answer, you’ll see a “message me” on the bottom right, press ‘m’, type your message and it’ll get printed over at my desk.

It’ll look something like this:

How it works

• My personal ssh website is made via https://github.com/charmbracelet/wish
• I take a text input
• This adds it to an in-memory store.
• A http router is created
• A Seeed Studio Xiao ESP32-C3 sends a “GET” request every ~5s
• If there’s a message, it’s removed from the in-memory store, printed on my desk

A few notes:

• I’m not providng an image of the esp32, not because it looks like a fire risk. But 100% because it looks like a fire risk.
• Bastard printer requires 2A 9V, I had to use a power cord from a broken dehumidifier to use it.
• Some thermal printers speak alien, it’s probably an incorrect baud rate.

The CH32v003F4P6

This tiny $0.1 microcontroller is adorable.

I’ve recently made a custom PCB with it and I wanted to use it with PlatformIO, primarily because:

EWWWWWWWWWWww

I hate proprietary IDE’s, enviroments etc. I don’t need Neovim to work with everything, but working with:

• Thonny for Micropython
• STM32CubeIDE for STM32’s
• ArduinoIDE for Arduinio’s
• MounriverStudio for WCH’s chips
• Segger for Nordic chips
• Neovim for the things I want to.
• VSCode for ESP-IDF

Is horrible, and that might be a slight exaggeration, but you get the idea.

Preparing

• Install PlatformIO I won’t baby you through this.

Assuming you’re on the VSCode extension, you’ll need to open a “debug terminal” and run:

pio pkg install -g -p https://github.com/Community-PIO-CH32V/platform-ch32v.git

Then add the following to /etc/udev/rules.d/99-platformio-dev.rules

SUBSYSTEM=="usb", ATTR{idVendor}="1a86", ATTR{idProduct}=="8010", GROUP="plugdev"
SUBSYSTEM=="usb", ATTR{idVendor}="4348", ATTR{idProduct}=="55e0", GROUP="plugdev"
SUBSYSTEM=="usb", ATTR{idVendor}="1a86", ATTR{idProduct}=="8012", GROUP="plugdev"

!!! RESTART YOUR SYSTEM !!!

Please for the love of god, I never restart my system after changing udev rules, thinking I can trick the kernel into change them. No. Restart your system.

Doing

Create a new PlatformIO project, I chose to do it with an Arduino UNO, then edit your platformio.ini to be something like this:

[env]
platform=ch32v
framework = arduino 
monitor_speed = 115200 
board_build_core = ch32v003

[env:ch32v003f4p6_evt_r0]
board = ch32v003f4p6_evt_r0

Plug in your WCH-LinkE and build and flash!

For me the code looked like this:

#include <Arduino.h>
#define LED D4

void setup() {
    pinMode(LED, OUTPUT);
}

void loop() {
    digitalWrite(LED, HIGH);
    delay(1000);
    digitalWrite(LED, LOW);
    delay(1000);
}

There we go :) a blinking LED, obviously change your D4 if that isn’t your LED, but you should be able to use the Arduino for programming your CH32V003’s now :)

Recently I’ve moved house, and with moving comes my beautiful new office, with a slight issue.

It’s hot.

Like really hot.

I bought and have used an Air-Conditioner, previously having temperatures of up to 35C… This worked great until it was too hot for nothing, but not hot enough to run the $0.25/hr AC. Let me be a bit clearer. I’m too cheap to spend $0.25/hr on being mildly hot, but I’m still hot

The solution? A custom STM32F1 PCB to control a 12V Noctua PWM fan :)

So armed with a burning desire (literally) to cool myself down, I decided to build a board using the STM32F103C8T6.

The “solution” was to use this to control a Noctua fan via PWM with maybe a little twisty knob thing to adjust the fan-speed.

Below is an attached image of the Schematic, with:

• 5 decoupling caps for VBAT&VDDx3 with a ferrite-bead on VDDA and some more caps.
• Switch to pull boot0 high/low
• usb-c because why on earth would I use anything else.. I need to justify my manic purchasing of usb-c cables…
• An external crystal, because obviously I need to run PWM at … 48Mhz
• AMS1117-3.3 LDO for voltage regulation.
• Lots of breakout sockets

The process went something like this:

Schematic

Design a beautiful schematic and triple, quadruple, quintuple check then check again.

Route

This is a two-step process where both are extremely pivotal to a working end product.

1. Route route route, very carefully, thinking alot about each decision.
2. Get annoyed and tired and half-ass the last 10%, which as we all know is actually the last 50%

It may be ugly, but it’s my ugly. After staring at my screen for too long, I finally hit order and waited whatever the opposite of patiently waiting is.

Once it had arrived and I gently ripped open the packaging I booted up my laptop and got to coding.

IOC

Create a .ioc file in STM32CubeMX that generated the initial boilerplate for me.

Coding

This part was the easiest of all due to my familiarity, it took maybe 30 minutes to get this basic example working

#include "main.h"

TIM_HandleTypeDef htim2;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM2_Init(void);

void SetFanSpeed(uint8_t speed_percent) {
    if (speed_percent > 100) {
        speed_percent = 100;
    }
    uint32_t pulse = (htim2.Init.Period + 1) * speed_percent / 100;
    
    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_2, pulse);
}

int main(void)
{
  HAL_Init();

  SystemClock_Config();

  MX_GPIO_Init();
  MX_TIM2_Init();
  
  HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);

  while (1)
  {
    SetFanSpeed(25);  
    HAL_Delay(2000);  
    
    SetFanSpeed(75);
    HAL_Delay(2000);  
    
    SetFanSpeed(100);
    HAL_Delay(2000);  
    
    for (uint8_t speed = 0; speed <= 100; speed++) {
        SetFanSpeed(speed);
        HAL_Delay(20);
    }
    
    for (uint8_t speed = 100; speed > 0; speed--) {
        SetFanSpeed(speed);
        HAL_Delay(20);
    }
  }
}

I should’ve checked this first…

** IT WORKS **

Oh and it does so everso beautifully. I believe I can compare this experience to parenthood, it’s my thing that I created that is working! Same thing right? Now you might notice that all this code does is ramp up and ramp down the fan? Why on earth would I create a custom PCB for a fan that just randomly spins up and down?

It didn’t work. The noctua fan was moving almost no air, and was too puny and small to create any measurable temperature difference.

Meaning to cool down my office it was practically useless.

Armed with this newfound knowledge I also discovered that with no PWM control, the fan ran at 100%, which was barely enough for me regardless.

The fan now sits on my desk, powered by a USB cable and buck-boost converter, gently blowing air on my houseplants. They seem to appreciate it. My office temperature remains unchanged - well until I got hot again and bought an industrial exhaust fan… but that’s a different story.

A silver lining?

Was it worth it? Well yes as a learning experience.

I learnt:

• STM32 HAL framework
• Alot about decoupling capacitors
• Crystal oscillators
• USB-C and the 5.1k resistors on CC
• The importance of practicality and not rushing to get to the end.

Isn’t that the point of hobbiest projects anyway? The friends we made along the way and such.

My next PCB is currently being made by JLCPCB which uses the beautiful CH32v003F4P6, a $0.1 microcontroller, for reading CO2 levels with an SCD40.

Here’s a sneak preview:

{ config, pkgs, ... }:
let
  grep = pkgs.gnugrep;
  desiredFlatpaks = [
    "com.bambulab.BambuStudio "
    "com.valvesoftware.SteamLink "
    "com.easyeda.EasyEDAPro  "
  ];
in
{
  # Literally hate bambu studio
  # love steam tho
  system.userActivationScripts.flatpakManagement = {
    text = ''
      # 2. Ensure the Flathub repo is added
      ${pkgs.flatpak}/bin/flatpak remote-add --if-not-exists flathub \
        https://flathub.org/repo/flathub.flatpakrepo

      # 3. Get currently installed Flatpaks
      installedFlatpaks=$(${pkgs.flatpak}/bin/flatpak list --app --columns=application)

      # 4. Remove any Flatpaks that are NOT in the desired list
      for installed in $installedFlatpaks; do
        if ! echo ${toString desiredFlatpaks} | ${grep}/bin/grep -q $installed; then
          echo "Removing $installed because it's not in the desiredFlatpaks list."
          ${pkgs.flatpak}/bin/flatpak uninstall -y --noninteractive $installed
        fi
      done

      # 5. Install or re-install the Flatpaks you DO want
      for app in ${toString desiredFlatpaks}; do
        echo "Ensuring $app is installed."
        ${pkgs.flatpak}/bin/flatpak install -y flathub $app
      done

      # 6. Remove unused Flatpaks
      ${pkgs.flatpak}/bin/flatpak uninstall --unused -y

      # 7. Update all installed Flatpaks
      ${pkgs.flatpak}/bin/flatpak update -y
    '';
  };
}

That’s it :) import it via your configuration.nix as such:

  imports = [
# Other things
    ./flatpack.nix
  ];

Setup

1. Project Generation: Use stm32cubemx. Select “CMake” as the toolchain/IDE.

2. Neovim ccls LSP Configuration:

lspconfig.ccls.setup({
    on_attach = on_attach,
    capabilities = capabilities,
    init_options = {
        cache = {
            directory = ".ccls-cache",
        },
    },
})

1. Nix devShell Dependencies:

{
  description = "Basic emed flake";
  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
  };
  outputs =
    {
      self,
      nixpkgs,
      flake-utils,
    }:
    flake-utils.lib.eachDefaultSystem (
      system:
      let
        pkgs = import nixpkgs {
          inherit system;
          overlays = [ ];
        };
      in
      {
        devShells.default = pkgs.mkShell {
          buildInputs = with pkgs; [
            cmake
            ccls
            gcc-arm-embedded
          ];
          shellHook = "";
        };
      }
    );
}

1. Build and LSP Setup: From your code’s root directory:

mkdir -p build
cd build
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON ..
make -j$(nproc)
cd ..
ln -s build/compile_commands.json .

Your LSP is now working!