Automation on Ronan's Blog

Building an Exhaustive ADS-B Feeder Station with Buildroot on Raspberry Pi 3

Sun, 03 May 2026 00:00:00 +0000

Following our work on maritime AIS, we are now targeting aviation. This guide explains how to build a professional-grade ADS-B station on a Raspberry Pi 3. We are using Buildroot to create a custom Linux firmware that is ultra-lightweight, boots in seconds, and runs entirely in RAM (read-only) to prevent SD card corruption.

1. Project Architecture

We use the BR2_EXTERNAL mechanism to keep our custom logic clean and portable. First, clone the stable Buildroot source:

git clone https://gitlab.com/buildroot.org/buildroot.git
cd buildroot
git checkout 2025.02.13

Our project tree is organized as follows:

.
├── buildroot/ # Official sources (git clone)
├── external-pi/ # Custom recipes layer
│ ├── Config.in
│ ├── external.desc
│ ├── external.mk
│ ├── board/ # <--- Boot configs (config.txt, cmdline.txt)
│ └── package/
│ ├── librtlsdr-blog/
│ ├── mlat-client/
│ └── readsb/
└── overlay/ # System files (Init, Network, Configs)
 ├── etc/
 │ ├── fr24feed.ini
 │ ├── init.d/
 │ │ ├── S50readsb
 │ │ ├── S60fr24
 │ │ ├── S99mlat-client-adsbfi
 │ │ └── S99mlat-client-adsbx
 │ ├── lighttpd/
 │ ├── modprobe.d/
 │ ├── network/
 │ └── wpa_supplicant.conf
 ├── usr/bin/fr24feed
 └── var/www/tar1090

2. The External Layer (external-pi)

These files declare the project to Buildroot:

external-pi/external.desc:

name: PI_FEEDER_EXT
desc: Station ADS-B pour Pi3

external-pi/external.mk:

include $(sort $(wildcard $(BR2_EXTERNAL_PI_FEEDER_EXT_PATH)/package/*/*.mk))

external-pi/Config.in (Menu integration):

source "$BR2_EXTERNAL_PI_FEEDER_EXT_PATH/package/librtlsdr-blog/Config.in"
source "$BR2_EXTERNAL_PI_FEEDER_EXT_PATH/package/readsb/Config.in"
source "$BR2_EXTERNAL_PI_FEEDER_EXT_PATH/package/mlat-client/Config.in"

3. Software Recipes & Compilation

A. Optimized Drivers: librtlsdr-blog

external-pi/package/librtlsdr-blog/Config.in:

config BR2_PACKAGE_LIBRTLSDR_BLOG
	bool "librtlsdr-blog"
	select BR2_PACKAGE_LIBUSB
	help
	 Version optimisée pour RTL-SDR Blog V4 avec support Bias-T.

	 https://github.com/rtlsdrblog/rtl-sdr-blog

external-pi/package/librtlsdr-blog/librtlsdr-blog.mk:

LIBRTLSDR_BLOG_VERSION = master
LIBRTLSDR_BLOG_SITE = $(call github,rtlsdrblog,rtl-sdr-blog,$(LIBRTLSDR_BLOG_VERSION))
LIBRTLSDR_BLOG_LICENSE = GPL-2.0+
LIBRTLSDR_BLOG_INSTALL_STAGING = YES

LIBRTLSDR_BLOG_DEPENDENCIES = libusb

# On active explicitement le détachement du driver kernel (DVB-T) 
# et l'installation des outils (rtl_sdr, rtl_biast, etc.)
LIBRTLSDR_BLOG_CONF_OPTS = \
	-DINSTALL_UDEV_RULES=ON \
	-DDETACH_KERNEL_DRIVER=ON

$(eval $(cmake-package))

B. The Decoder: readsb

external-pi/package/readsb/Config.in:

config BR2_PACKAGE_READSB
	bool "readsb"
	select BR2_PACKAGE_LIBRTLSDR_BLOG
	select BR2_PACKAGE_NCURSES
	select BR2_PACKAGE_ZLIB
	select BR2_PACKAGE_ZSTD
	help
	 Readsb est un décodeur ADS-B haute performance.

external-pi/package/readsb/readsb.mk:

READSB_VERSION = master
READSB_SITE = $(call github,wiedehopf,readsb,$(READSB_VERSION))
READSB_DEPENDENCIES = librtlsdr-blog ncurses zlib zstd
READSB_LICENSE = GPL-3.0

# On utilise le hook SED pour les versions
define READSB_FIX_VERSION_MACROS
	sed -i 's/READSB_SHORT_VERSION/"2025"/g' $(@D)/json_out.c
	sed -i 's/READSB_SHORT_COMMIT/"v4"/g' $(@D)/json_out.c
endef
READSB_POST_PATCH_HOOKS += READSB_FIX_VERSION_MACROS

# On passe RTLSDR=yes ET on force le flag de compilation manuellement dans CFLAGS
READSB_MAKE_OPTS = \
	RTLSDR=yes \
	CFLAGS="$(TARGET_CFLAGS) -D_GNU_SOURCE -D_DEFAULT_SOURCE -DENABLE_RTLSDR"

define READSB_BUILD_CMDS
	$(TARGET_MAKE_ENV) $(MAKE) $(TARGET_CONFIGURE_OPTS) -C $(@D) $(READSB_MAKE_OPTS)
endef

define READSB_INSTALL_TARGET_CMDS
	$(INSTALL) -D -m 0755 $(@D)/readsb $(TARGET_DIR)/usr/bin/readsb
	$(INSTALL) -D -m 0755 $(@D)/viewadsb $(TARGET_DIR)/usr/bin/viewadsb
endef

$(eval $(generic-package))

C. MLAT Client

external-pi/package/mlat-client/Config.in:

config BR2_PACKAGE_MLAT_CLIENT
	bool "mlat-client"
	depends on BR2_PACKAGE_PYTHON3
	select BR2_PACKAGE_PYTHON_PYASYNCORE
	select BR2_PACKAGE_PYTHON_PYASYNCHAT²
	select BR2_PACKAGE_PYTHON3_ZLIB
	help
	 Mode S Multilateration client for ADS-B feeders.

	 https://github.com/mutability/mlat-client

comment "mlat-client needs python3"
	depends on !BR2_PACKAGE_PYTHON3

external-pi/package/mlat-client/mlat-client.mk:

MLAT_CLIENT_VERSION = 0.2.13
MLAT_CLIENT_SITE = $(call github,mutability,mlat-client,v$(MLAT_CLIENT_VERSION))
MLAT_CLIENT_LICENSE = GPL-3.0
MLAT_CLIENT_LICENSE_FILES = COPYING
MLAT_CLIENT_SETUP_TYPE = setuptools

$(eval $(python-package))

4. System Configuration (Overlay)

The overlay directory contains custom configuration files and pre-compiled binaries that are merged into the final root filesystem.

Note: Some binaries like fr24feed and the tar1090 web interface files should be placed manually in the overlay/ directory before building if they are not managed by a Buildroot recipe.

Network & WiFi

overlay/etc/network/interfaces:

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet dhcp

auto wlan0
iface wlan0 inet dhcp
 pre-up sleep 2
 wpa-conf /etc/wpa_supplicant.conf

overlay/etc/wpa_supplicant.conf:

country=FR
network={
 ssid="YOUR_SSID"
 psk="YOUR_PASSWORD"
}

overlay/etc/modprobe.d/rtlsdr-blacklist.conf:

blacklist dvb_usb_rtl28xxu
blacklist rtl2832
blacklist rtl2830

Init Scripts (The Automation)

overlay/etc/init.d/S50readsb (The Core Decoder):

#!/bin/sh

DAEMON="readsb"
BINARY="/usr/bin/readsb"
SITE_UUID="YOUR_UUID"

# Arguments finaux
ARGS="--device-type rtlsdr \
 --net \
 --fix \
 --dcfilter \
 --lat YOUR_LAT \
 --lon YOUR_LON \
 --net-ri-port 0 \
 --net-ro-port 30002 \
 --net-bi-port 30004 \
 --net-bo-port 30005 \
 --write-json /tmp/readsb \
 --net-connector feed.adsb.fi,30004,beast_reduce_out,uuid=$SITE_UUID \
 --net-connector feed.adsbexchange.com,30004,beast_reduce_out"

case "$1" in
 start)
 echo -n "Starting $DAEMON: "
 /usr/bin/rtl_biast -b 1 > /dev/null 2>&1
 sleep 1
 start-stop-daemon -S -b -x $BINARY -- $ARGS
 [ $? -eq 0 ] && echo "OK" || echo "FAIL"
 ;;
 stop)
 echo -n "Stopping $DAEMON: "
 start-stop-daemon -K -x $BINARY
 [ $? -eq 0 ] && echo "OK" || echo "FAIL"
 ;;
 restart)
 $0 stop
 sleep 1
 $0 start
 ;;
 *)
 echo "Usage: $0 {start|stop|restart}"
 exit 1
 ;;
esac

overlay/etc/init.d/S99mlat-client-adsbx (Feed ADSBExchange):

#!/bin/sh
NAME="mlat-client-adsbx"
DAEMON="/usr/bin/mlat-client"
PIDFILE="/var/run/$NAME.pid"

ARGS="--input-type dump1090 \
 --input-connect 127.0.0.1:30005 \
 --lat YOUR_LAT \
 --lon YOUR_LON \
 --alt 45m \
 --user YOUR_USER \
 --server feed.adsbexchange.com:31090 \
 --no-udp \
 --results beast,connect,127.0.0.1:30004"

case "$1" in
 start)
 echo -n "Starting $NAME: "
 start-stop-daemon -S -q -b -m -p $PIDFILE -x $DAEMON -- $ARGS
 echo "OK"
 ;;
 stop)
 echo -n "Stopping $NAME: "
 start-stop-daemon -K -q -p $PIDFILE
 echo "OK"
 rm -f $PIDFILE
 ;;
 restart)
 $0 stop
 sleep 1
 $0 start
 ;;
 *)
 echo "Usage: $0 {start|stop|restart}"
 exit 1
 ;;
esac

overlay/etc/init.d/S99mlat-client-adsbfi (Feed ADSB.fi):

#!/bin/sh
NAME="mlat-client-adsbfi"
DAEMON="/usr/bin/mlat-client"
PIDFILE="/var/run/$NAME.pid"

ARGS="--input-type dump1090 \
 --input-connect 127.0.0.1:30005 \
 --lat YOUR_LAT \
 --lon YOUR_LON \
 --alt 45m \
 --user YOUR_USER \
 --server feed.adsb.fi:31090 \
 --no-udp \
 --results beast,connect,127.0.0.1:30004"

case "$1" in
 start)
 echo -n "Starting $NAME: "
 start-stop-daemon -S -q -b -m -p $PIDFILE -x $DAEMON -- $ARGS
 echo "OK"
 ;;
 stop)
 echo -n "Stopping $NAME: "
 start-stop-daemon -K -q -p $PIDFILE
 echo "OK"
 rm -f $PIDFILE
 ;;
 restart)
 $0 stop
 sleep 1
 $0 start
 ;;
 *)
 echo "Usage: $0 {start|stop|restart}"
 exit 1
 ;;
esac

overlay/etc/init.d/S60fr24 (FlightRadar24 Feed):

#!/bin/sh
DAEMON="fr24feed"
BINARY="/usr/bin/fr24feed"

case "$1" in
 start)
 echo -n "Starting $DAEMON: "
 sleep 2
 start-stop-daemon -S -b -x $BINARY
 [ $? -eq 0 ] && echo "OK" || echo "FAIL"
 ;;
 stop)
 echo -n "Stopping $DAEMON: "
 start-stop-daemon -K -x $BINARY
 [ $? -eq 0 ] && echo "OK" || echo "FAIL"
 ;;
 restart)
 $0 stop
 sleep 1
 $0 start
 ;;
 *)
 echo "Usage: $0 {start|stop|restart}"
 exit 1
 ;;
esac

Feeder Configurations

overlay/etc/fr24feed.ini:

receiver="beast-tcp"
fr24key="YOUR_FR24_KEY"
host="127.0.0.1:30005"
bs="no"
raw="no"
logmode="1"
logpath="/tmp"
mlat="yes"
mlat-without-gps="yes"

overlay/etc/lighttpd/lighttpd.conf (Web Interface):

server.modules += ( "mod_alias", "mod_setenv" )
server.document-root = "/var/www/tar1090"
server.port = 80
index-file.names = ( "index.html" )

mimetype.assign = (
 ".html" => "text/html",
 ".css" => "text/css",
 ".js" => "application/javascript",
 ".json" => "application/json",
 ".png" => "image/png",
 ".svg" => "image/svg+xml"
)

alias.url += ( "/data/" => "/tmp/readsb/" )

$HTTP["url"] =~ "^/data/" {
 setenv.add-response-header = ( "Cache-Control" => "no-cache, no-store, must-revalidate" )
}

5. RAM-Only Boot Configuration

To run the OS entirely in RAM, we use the initramfs strategy. This loads the rootfs.cpio.gz into the Raspberry Pi’s memory at boot time. You have two options to implement this:

Method A: Automated (Buildroot Integration)

This is the professional way. The files are generated correctly every time you run make.

Prepare your custom board files: Create a folder external-pi/board/ and create two files:

external-pi/board/config.txt:

# RAM Boot Config
initramfs rootfs.cpio.gz followkernel
# Enable UART for console
enable_uart=1

external-pi/board/cmdline.txt:

console=serial0,115200 console=tty1 root=/dev/ram0 rw rootwait

Configure Buildroot (make menuconfig):
- Filesystem images:
  - Enable cpio the root file system.
  - Compression: gzip.
- Target packages -> Hardware handling:
  - Select rpi-firmware.
  - Set Configuration file to $(BR2_EXTERNAL_PI_FEEDER_EXT_PATH)/board/config.txt.
- System configuration:
  - Set Custom scripts to run after creating the images to point to a script that copies your cmdline.txt to the output folder (or use the default RPi post-image script and point it to your custom file).

Method B: Manual (Quick Edit on SD Card)

If you don’t want to touch Buildroot files, you can edit the files on the SD card after flashing.

Flash the SD card as described in Section 7.
Mount the BOOT partition on your PC.
Edit config.txt: Add the line initramfs rootfs.cpio.gz followkernel.
Edit cmdline.txt: Replace the content with console=serial0,115200 console=tty1 root=/dev/ram0 rw rootwait.

Note: The Buildroot files in buildroot/board/raspberrypi/ are templates. You should never edit them directly; always use a custom board directory in your external-pi layer as shown in Method A.

6. Buildroot Setup Checklist

Enable these options in make menuconfig to match our project’s requirements:

Target options: Cortex-A53, NEON-VFPV4, Hard float (EABIhf), instructions ARM (not Thumb2).
Toolchain: Glibc library, Linux Headers 6.6.x, GCC 13.x, Binutils 2.43.x. Enable Wchar, Locale, and C++ support.
Kernel: Custom Raspberry Pi kernel (bcm2709_defconfig) using the 6.6.y branch. Enable Device Tree support and DTB overlay support.
System Configuration:
- Root login enabled (password: root).
- DHCP enabled on eth0.
- BR2_ROOTFS_OVERLAY pointing to your overlay/ directory.
- Purge locale (C, en_US).
WiFi Stack: linux-firmware -> Broadcom BCM43xxx & Cypress CYW43xxx.
Networking: lighttpd (with zlib), dropbear (SSH), wpa_supplicant (with nl80211), chrony (NTP sync).
Tools: bash, python3 (with zlib, unicodedata, pyasyncore, pyasynchat), socat, kmod (tools), ca-certificates.
Libraries: libusb, ncurses, readline, zlib, zstd, xxhash.
Filesystem: cpio with gzip compression.

7. Deployment

Method A: Manual SD Formatting

# Format 1 FAT32 partition on SD card
sudo mkfs.vfat -F 32 -n BOOT /dev/sdX1
# Copy boot images from output/images/
sudo cp zImage rootfs.cpio.gz bcm2710-rpi-3-b.dtb rpi-firmware/* /mnt/sdcard/

Method B: Network Deployment (Fast Iteration)

# Update your running Pi remotely
scp -O output/images/zImage output/images/rootfs.cpio.gz \
 output/images/bcm2710-rpi-3-b.dtb root@192.168.1.123:/boot/
ssh root@192.168.1.123 "reboot"

8. Results & Performance

Once the station is up and running, you can access the local web interface (tar1090) to view real-time traffic. The custom Buildroot firmware ensures extremely low CPU usage and high stability.

Hayward Aquarite integration in Home Assistant with Tasmota

Sun, 21 Jan 2024 00:00:00 +0000

In order to get an Hayward Aquarite integration in Home Assistant with Tasmota we’ll go through several steps including wiring the ESP32 to the Aquarite and then the Home Assistant configuration.

Hardware : ESP32

Step 1 : Prototype

We’ll use :
- ESP32 from AZ-Delivery
- RS485 to TTL adapter

The wiring will be done as follow :

Step 2 : Final version

For the final version, we’ll use an M5stack ESP32 with a RS485 tail, in order to have a clean, small and 10v powered device.

Software : Tasmota

With the “Sugar Valley NeoPool module” Tasmota support natively this salt chlorinator.
This option is not compile in the standard version, we’ll need to compile Tasmota in order to compile this functionality.

Tasmota compilation

Install Plateformio :

sudo apt-get install python-pip
sudo pip install -U platformio

Get Tasmota files :

git clone https://github.com/arendst/Tasmota.git

Before compiling, let’s enable the support of the Sugar Valley NeoPool chlorinators :

vim tasmota/my_user_config.h

And modify as follow :

// !!! Remember that your changes GOES AT THE BOTTOM OF THIS FILE right before the last #endif !!!

#ifndef USE_NEOPOOL
#define USE_NEOPOOL
#endif

#endif // _USER_CONFIG_OVERRIDE_H_

Then compile and upload :

platformio run -e tasmota32 --target upload --upload-port /dev/ttyUSB0

Tasmota configurtion

Configure IO as follow :

Then wire it, start it and you should be able to use data :

Home assistant integration

Once done, you could process to MQTT integration and have a nice native integration in Home Assistant with Tasmota integration.

You’re done with Hayward Aquarite integration in Home Assistant with Tasmota.

PID regulation : Led brightness regulation with Arduino

Tue, 16 Jan 2024 00:00:00 +0000

PID regulation : Led brightness regulation with Arduino. To get this done we’ll first do a bit of wiring and then program our Arduino.

Led wiring and control

Wiring

Our led is a Yellow led with a 2.4v forward voltage at 20mA.
Our current source (Arduino) delivers 3.3v.
Resistor calculation : R = (3.3v - 2.4 V) / 25 mA = 0.9v / 0.02A = 45Ω

We’ll wire the cathode to one of the digital I/O of the Arduino. Note, we chose the digital I/O #3 as we’ll need to use PWM (described below).

As I just had a 47Ω resistor, this will work :

Control

In order to control the brightness of the LED, we’ll use the Pulse-width modulation (PWM), or pulse-duration modulation (PDM) :

To do this, we’ll use the following function : analogWrite(pin, value)
- pin: the pin to write to.
- value: the duty cycle: between 0 (always off) and 255 (always on)

Code sample :

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

void loop()
{
//Analog write
analogWrite(3, 64); 
}

Results (0, 25%, 75%, 100%) :

Led brightness regulation

Sensor

We’ll add a light sensor as wired below :

Just place the sensor in front of the LED:

Regulation

In order to regulate, we’ll use a proportional–integral–derivative controller. A PID controller is a control loop feedback mechanism (controller) commonly used in industrial control systems. A PID controller continuously calculates an error value as the difference between a desired setpoint and a measured process variable. The controller attempts to minimize the error over time by adjustment of a control variable.

Here is the code :

#include <PID_v1.h>
//Variables
double Setpoint, Input, Output;
//PID parameters
double Kp=0, Ki=10, Kd=0;

//Start PID instance
PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);

void setup()
{
 //Start a serial connection to send data by serial connection
 Serial.begin(9600); 
 //Set point : Here is the brightness target
 Setpoint = 100;
 //Turn the PID on
 myPID.SetMode(AUTOMATIC);
 //Adjust PID values
 myPID.SetTunings(Kp, Ki, Kd);
}

void loop()
{
 //Read the value from the light sensor. Analog input : 0 to 1024. We map is to a value from 0 to 255 as it's used for our PWM function.
 Input = map(analogRead(0), 0, 1024, 0, 255); 
 //PID calculation
 myPID.Compute();
 //Write the output as calculated by the PID function
 analogWrite(3,Output);
 //Send data by serial for plotting 
 Serial.print(Input);
 Serial.print(" ");
 Serial.println(Output); 
}

PID Parameters :

Kp accounts for present values of the error (e.g. if the error is large and positive, the control variable will be large and negative).
Ki accounts for past values of the error (e.g. if the output is not sufficient to reduce the size of the error, the control variable will accumulate over time, causing the controller to apply a stronger action).
Kd accounts for possible future values of the error, based on its current rate of change.

The Arduino 1.6.6 comes with a tool called “Serial plotter”, that might be useful to graph our data:

The measured value is note stable, probably due to the PWM. A solution would be to smooth the results by doing an average on the lasts results, in order to filter the high frequency changes.

Note : You can graph several values at the same time, you just need to send them on the same line, with a space as a delimiter.

When I disrupt the system with an external light, we clearly see that the system tries to keep the brightness at the setpoint (100) by managing the led control value :

To conclude, here is how the system is handling a change from 0 to setpoint, or from setpoint to 0 :

You’re done with PID regulation : Led brightness regulation with Arduino

Siemens PLC simulation with virtual commissioning

Sun, 14 Jan 2024 00:00:00 +0000

For Siemens PLC simulation with virtual commissioning we’ll use PLCSIM Advanced and C# co-simulation.

Configuration

We’ll run the simulator and the editor on two computers :

Simulator configuration

First let’s start an instance with the following parameters :

Once started, it should be like that :

PLC Programming

Hardware configuration

Let’s do a simple configuration as follow :

Network configuration :
- PLC_1 : 192.168.1.1/24
- IO device_1 : 192.168.1.2/24

Note : On the simulator, we have different IP addresses for all the network interfaces : Ethernet adapter, PLCSIM virtual ethernet adapter, PLC and I/Os !

With the following I/Os :

Note that you’ll need to activate this option in the project settings :

Program

Our program will be very simple ! OB1 will toggle a bit every second :

And FB1 will do a safety check between the relay output and the input feedback :

Compiling and loading

You should be able to compile and load :

Simulation

As soon as you’ll run the program, you should have an error on the feedback monitoring :

Co-simulation

To solve this issue, we’ll running co-simulation with C#. The script will check the output value (%Q9.0) and set the feedback (%I0.0) accordingly. We’ll be using sharpdevelop as IDE.

Import DLL

Importing the DLL is easy :

Then we write a short program :

/*
 * Created by SharpDevelop.
 */
using System;
using System.Threading;
using Siemens.Simatic.Simulation.Runtime;

namespace CPU1515F
{
	class Program
	{
		public static void Main(string[] args)
		{
			Console.WriteLine("Starting simulation");
			//Use it for local instance
			//IInstance myInstance = SimulationRuntimeManager.CreateInterface("Golf8");

			//Use it for remote instance
			IRemoteRuntimeManager myRemoteInstance = SimulationRuntimeManager.RemoteConnect("192.168.1.101:50000");
			IInstance myInstance = myRemoteInstance.CreateInterface("1515F");
		
			//Update tag list from API
			Console.WriteLine("Tags synchronization");
			myInstance.UpdateTagList();
		
			//Start a thread to synchronize feedbacks inputs 
			Thread tFeedbacks = new Thread(()=>synchroFeedbacks(myInstance));
			tFeedbacks.Start();
			
			//Allow the user to quit simulation
			Console.WriteLine("Simulation running");
			Console.WriteLine("Press any key to quit . . . ");
			Console.ReadKey(true);
		}
		
		static void synchroFeedbacks(IInstance myInstance)
 {
			while(true){
				//Keep %I and %Q opposite
				myInstance.WriteBool("FB_KA1", !myInstance.ReadBool("KA1"));	
			}
		}
	}
}

And run it :

Once acknowledged, we should not have any issue.

Using the trace tool, we can confirm that it’s running perfectly fine, updating the input in around 100ms.

You’re done with Siemens PLC simulation with virtual commissioning.