DEV Community: Ashen Chathuranga

DevRank LK: Sri Lanka's GitHub Developer Leaderboard is Live – Join and Get Ranked! 🇱🇰

Ashen Chathuranga — Fri, 13 Mar 2026 18:37:41 +0000

Hey Sri Lankan developers! 👋🇱🇰

Our local tech scene is full of talent, but we rarely see a public ranking that actually celebrates our open-source contributions. Until now.

Introducing DevRank LK — a brand-new, fully automated weekly leaderboard that ranks Sri Lankan GitHub developers based on real activity over the past 12 months.

How the Ranking Works

Every Sunday a GitHub Action runs and calculates a score using this transparent formula:

score = (commits × 3) + (PRs × 5) + (issues × 2) + (stars × 4) + (followers × 1)

No magic. Just pure GitHub data.

Live Leaderboard → https://ktauchathuranga.github.io/devrank-lk/

Current Top 5 (as of today)

@sameerasw – 35,538 🔥
@ktauchathuranga – 5,056
@Minokainduwara – 1,691
@Dineshs737 – 1,684
@Pasindu-Jayasundara – 1,618

(Only 20 developers are listed right now — perfect time to get in early and climb the ranks!)

Why You Should Opt In Right Now

Get public recognition for the work you already do
Friendly competition with fellow Lankan devs
Extra motivation to ship more open-source
Help put Sri Lanka on the global developer map
It’s completely free and open to any Sri Lankan developer

How to Join (Takes literally 2 minutes)

Go to the repo: https://github.com/ktauchathuranga/devrank-lk
Click Fork
Open data/users.json
Add your entry at the very end (before the closing ]), like this:

  { "github": "your-github-username", "note": "Optional short note (e.g. 'bl4ke.me' or 'Working at XYZ')" }

Don’t forget the comma after the previous entry!
Commit → Create Pull Request

That’s it. Once your PR is merged you’ll appear in the next weekly update.

Let’s Grow This Together

If you’re a Sri Lankan developer (or Sri Lankan origin and active in the community), I strongly encourage you to opt in today. The more of us who join, the more meaningful and competitive this leaderboard becomes.

After you join, drop your GitHub username in the comments below — I’ll follow you and cheer you on! Tag your SL dev friends too.

Let’s show the world what Sri Lankan developers can do! 💪

SriLanka #developers #opensource #GitHub #DevRankLK #srilankantech #coding #community

Reviving Tech: Building OpenPager

Ashen Chathuranga — Fri, 27 Feb 2026 23:43:32 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

What I Built with Google Gemini

Between organizing STEAM workshops and teaching my 4-month beginner Arduino course, I am constantly exploring new ways to push the boundaries of what microcontrollers can achieve. I wanted a project that moved beyond basic sensor reading and dove deep into the complexities of radio frequency communication and real-time processing.

That drive led to OpenPager: a high-precision POCSAG (pager) transceiver library for Arduino-compatible microcontrollers (ESP8266, ESP32) and the TI CC1101 radio module.

The Features:

Auto-Baud Decoding: Automatically detects and receives 512, 1200, and 2400 baud messages simultaneously using parallel software decoders.
True Non-Blocking RX: A hardware timer ISR samples GDO0 at ~19.2 kHz. The main loop() just drains a ring buffer, ensuring it never busy-waits or bit-bangs.
Dual Radio Mode: Supports using two CC1101 modules on the same SPI bus, allowing for true simultaneous TX and RX operations without ever dropping a received packet.

Gemini's Role in the Build:
Implementing a protocol from the 1980s on modern IoT hardware requires a lot of bitwise gymnastics and register configuration. I leaned heavily on Google Gemini for:

Register Configurations: Generating baseline hex values for CC1101 initialization, specifically calculating data rate multipliers for the different baud rates.
BCH Error Correction: Translating the mathematical polynomials of POCSAG's BCH(31,21) error-correcting code into efficient, bitwise C++ functions.
Alphanumeric Decoding: Helping write the logic to unpack 7-bit ASCII from 20-bit payload chunks, which requires reversing bits and shifting across arbitrary boundaries.

Demo

You can view the full project, documentation, and source code on GitHub:
https://github.com/ktauchathuranga/openpager

Here is a quick look at the non-blocking architecture in action. While the hardware timer samples the radio in the background, the main loop remains completely free to run other tasks—like a heartbeat LED, sensor reads, and uptime tracking—without stuttering:

void loop() {
    // Pager processing (non-blocking)
    pager.loop(); [cite: 14]

    uint32_t now = millis(); [cite: 14]

    // Task 1: LED heartbeat
    static uint32_t lastBlink = 0; [cite: 14]
    static bool ledOn = false; [cite: 14]

    if (now - lastBlink >= HEARTBEAT_MS) { [cite: 15]
        lastBlink = now; [cite: 15]
        ledOn = !ledOn; [cite: 15]
        digitalWrite(HEARTBEAT_LED, ledOn); [cite: 16]
    }

    // Task 2: Analog sensor read
    static uint32_t lastSensor = 0; [cite: 16]
    if (now - lastSensor >= SENSOR_MS) { [cite: 17]
        lastSensor = now; [cite: 17]
        int val = analogRead(SENSOR_PIN); [cite: 18]
        Serial.printf("[Sensor] A0 = %d\n", val); [cite: 18]
    }
}

What I Learned

This project was a masterclass in hardware timers and interrupt safety.

When building the non-blocking architecture, I had to ensure the ISR executed in sub-microseconds. I learned the hard way about what you can and cannot do inside an Interrupt Service Routine. Passing data from the ISR to the main loop using a volatile ring buffer taught me a ton about atomicity and race conditions. For example, on the ESP8266, using Timer1 for the ISR means standard functions like Servo and analogWrite (PWM) are entirely unavailable while receiving.

Additionally, managing the ESP8266's software watchdog timer was an unexpected lesson. During transmission, clocking out bits blocks the processor. I had to strategically insert yield() calls on the ESP8266 to prevent watchdog resets, while carefully avoiding this on the ESP32 to prevent FreeRTOS from introducing multi-millisecond gaps that corrupt bit timing.

Looking forward, I want to take this rock-solid asynchronous architecture and apply it to modern IoT projects. I'm currently conceptualizing a Smart Agro-Cloud Observer, and these lessons on keeping the main loop non-blocking while handling strict sensor timing will be invaluable.

Google Gemini Feedback

What worked well:
Gemini is phenomenal at explaining binary and bitwise operations. When staring at a hex dump of a pager transmission, I could paste the raw binary into Gemini, and it would perfectly break down the 32-bit codewords into the Address, Function bits, and BCH parity bits. It made debugging the decoder significantly less painful.

Where I ran into friction:
Where Gemini struggled was with the highly specific, hardware-dependent quirks of the ESP32 and ESP8266 SDKs.
For instance, when setting up the SPI bus on the ESP32, Gemini suggested a standard SPI.begin(). However, the ESP32's default SPI implementation claims GPIO 5 as the SS pin. If you're using GPIO 5 for the CC1101's GDO0 interrupt pin (like I was), this creates bus contention. I had to manually debug this and pass -1 for the SS pin to prevent the conflict. AI is incredible for logic and algorithms, but it doesn't always have the "street smarts" of undocumented hardware quirks.

Introducing OpenPager: A POCSAG Transceiver Library for Arduino

Ashen Chathuranga — Sat, 07 Feb 2026 14:55:29 +0000

I recently released OpenPager, a library for Arduino-compatible microcontrollers that handles POCSAG (pager protocol) communication.

It is designed specifically for the TI CC1101 radio transceiver paired with ESP8266 or ESP32 boards. While there are other radio libraries out there, OpenPager focuses specifically on robust POCSAG implementation with features like parallel auto-baud detection and software-based signal synchronization.

It is available now in both the Arduino Library Registry and the PlatformIO Registry.

The Hardware

To use this, you need:

MCU: ESP8266, ESP32, or similar Arduino-compatible board.
Radio: TI CC1101 module (SPI interface).

The library is optimized for the ESP architecture, leveraging its speed for the software PLL required for accurate decoding.

Key Features

Dual Mode: Supports both transmitting and receiving (half-duplex).
Auto-Baud Detection: The receiver runs parallel decoders to detect and receive 512, 1200, and 2400 baud messages simultaneously.
Protocol Support: Handles Alphanumeric (ASCII), Numeric (BCD), and Tone-only messages.
Error Correction: Implements BCH error detection (SECDED).
Signal Handling: Automatic polarity detection for inverted signals and RSSI monitoring.

Installation

PlatformIO
Add this to your platformio.ini:

lib_deps =
    ktauchathuranga/openpager

Arduino IDE
Search for "OpenPager" in the Library Manager.

Usage: Receiving Messages

The most complex part of pager protocols is usually handling different baud rates. OpenPager handles this by spawning three independent decoders internally. You just set it to "0" to enable auto-scanning for all rates.

Here is a callback-based example:

#include <OpenPager.h>

// Initialize with CSN pin (15) and GDO0 pin (5)
OpenPager pager(15, 5);

void onMessage(OpenPagerMessage msg) {
    Serial.printf("[RIC: %lu] [Baud: %d] %s\n", msg.ric, msg.baudRate, msg.text);
}

void setup() {
    Serial.begin(115200);

    // Initialize radio at 433.920 MHz
    // 0 = Auto-Baud mode (scans 512, 1200, 2400 simultaneously)
    pager.begin(433.920, 0); 

    pager.setCallback(onMessage);
    pager.startReceive(0); 
}

void loop() {
    // The library handles decoding in the background; 
    // messages appear via the callback.
}

Usage: Transmitting Messages

Transmission is straightforward. You specify the RIC (Receiver ID), function code, message body, and baud rate.

#include <OpenPager.h>

OpenPager pager(15, 5);

void setup() {
    // Initialize at 433.920 MHz with a base rate of 1200
    pager.begin(433.920, 1200);
}

void loop() {
    // Send a message to RIC 1234567
    // Func: 3, Text: "Hello World", Baud: 1200, IsAlpha: true
    pager.transmit(1234567, 3, "Hello World", 1200, true);

    delay(5000);
}

Under the Hood

The CC1101 operates in asynchronous mode, outputting raw demodulated data on the GDO0 pin. OpenPager processes this stream using a software PLL to maintain bit synchronization.

The interesting part is the RX Architecture:

Parallel Decoding: The library runs three decoder instances (512, 1200, 2400) in parallel.
Sync Lock: All decoders process the signal; when a valid sync word is detected, the appropriate decoder locks onto the stream.
Jitter Handling: On the ESP32, 2400 baud works reliably. On the ESP8266, interrupt jitter (~3-5µs) makes 2400 baud more challenging, but lower rates work perfectly.

SSTV Encoder With 10+ Modes

Ashen Chathuranga — Sat, 24 Jan 2026 01:56:19 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

SSTV Encoder, built it using rust, you can input an image and it will create a .wav file according to your chosen mode. it support,

Mode	VIS Code	Resolution	Time	Color Space
`martin1`	0xAC	320×256	114.3s	RGB (GBR)
`martin2`	0x28	320×256	58.1s	RGB (GBR)
`scottie1`	0x3C	320×256	109.6s	RGB (GBR)
`scottie2`	0xB8	320×256	71.1s	RGB (GBR)
`scottiedx`	0xCC	320×256	268.9s	RGB (GBR)
`robot36`	0x88	320×240	36.0s	YUV
`robot72`	0x0C	320×240	72.0s	YUV
`pd120`	0x5F	640×496	126.1s	YUV
`pd180`	0x60	640×496	187.1s	YUV
`pd290`	0xDE	800×616	288.7s	YUV
`bw8`	0x82	160×120	8.0s	Grayscale
`bw12`	0x86	160×120	12.0s	Grayscale

Once you generate the .wav files, you can decode them using any standerd SSTV decoder.

Demo

My Experience with GitHub Copilot CLI

When it takes months to build a tool like this, With GitHub Copilot under my supervision built it in few days. this helps me to explore more areas otherwise i will miss. experience is actually good, everything in CLI making things convenient. and i like the way it asks clarifying questions before proceeding and giving me recommended options to run kinda cool.

Project link - https://github.com/ktauchathuranga/sstv

Complete ADS-B Decoder in Rust: Track Aircraft in Real-Time with RTL-SDR

Ashen Chathuranga — Mon, 19 Jan 2026 09:37:25 +0000

Have you ever wondered how websites like FlightRadar24 track thousands of aircraft in real-time? The answer lies in ADS-B (Automatic Dependent Surveillance-Broadcast) - a technology where aircraft continuously broadcast their position, altitude, speed, and identification. Best part? You can receive these signals yourself with a $20 USB dongle!

I've built a complete ADS-B decoder in Rust that rivals the popular dump1090, adding several improvements and comprehensive protocol documentation. Let me show you what makes this project special.

What Can You Track?

With just an RTL-SDR dongle and a simple antenna, you can:

Track aircraft up to 250+ nautical miles away
See their callsigns (flight numbers)
Monitor altitude, speed, and heading in real-time
Calculate distance and bearing from your location
Detect emergency squawk codes (7500/7600/7700)
Access additional data like IAS, Mach number, and vertical rate from BDS registers

Hex     Flight   Alt    Speed  Lat      Lon       Msgs  Seen  Distance  Bearing
89645A  UAE80T   35000  465kt  5.8912   79.4521   142   0s    245.2km   312°
4D2023  AMC421   22000  385kt  37.074   13.799    87    1s    187.8km   158°

Key Features

Complete Mode S Decoding

This isn't a minimal proof-of-concept - it's a full-featured decoder supporting:

All major Downlink Formats: DF0, DF4, DF5, DF11, DF16, DF17, DF20, DF21
CPR Position Decoding: Both global and local Compact Position Reporting
Error Correction: Single-bit and optional two-bit error correction via CRC syndrome
BDS Register Decoding: Extract Comm-B data from DF20/DF21 messages

Smart Aircraft Filtering

Real-world RF environments are noisy. The decoder includes:

Ghost aircraft filtering with configurable message thresholds
Persistent ICAO tracking with TTL-based cleanup
ICAO address validation and recovery from CRC
Smart handling of position data across zone boundaries

Emergency Detection

Automatically highlights emergency situations with color-coded alerts:

7500 - Hijacking
7600 - Radio Failure
7700 - General Emergency

Multiple Output Formats

Stream decoded data in various formats:

Raw TCP (port 30002) - hex messages
SBS/BaseStation (port 30003) - compatible with Virtual Radar Server
JSON API (port 8080) - for web applications
Interactive terminal - with real-time updates

Getting Started

Hardware You'll Need

RTL-SDR dongle ($20-30) or HackRF One ($300+)
Antenna - a simple 1090 MHz dipole works great (6.9cm elements)
Computer - even a Raspberry Pi works!

Installation

# Install RTL-SDR libraries
# Fedora/RHEL
sudo dnf install rtl-sdr rtl-sdr-devel

# Ubuntu/Debian  
sudo apt install rtl-sdr librtlsdr-dev

# Clone and build
git clone https://github.com/ktauchathuranga/adsb.git
cd adsb
cargo build --release

Running It

# Basic usage with RTL-SDR
./target/release/adsb --interactive

# With HackRF One
./target/release/adsb --hackrf --interactive

# Add your location for distance/bearing calculations
./target/release/adsb --interactive \
  --lat 6.9271 --lon 79.8612

# Enable networking for web access
./target/release/adsb --net --interactive

Then open http://localhost:8080 to see aircraft on a map!

How ADS-B Works

One thing that sets this project apart is its comprehensive protocol documentation. The README includes a complete deep-dive into:

Signal Characteristics

Frequency: 1090 MHz
Modulation: PPM (Pulse Position Modulation)
Data Rate: 1 Mbit/s
Message Types: 56-bit (short) and 112-bit (long)

Every message starts with a distinctive preamble:

Preamble (8 µs):
 ▲
1│    █   █         █   █
 │    █   █         █   █
0└──────────────────────────────────►
      0   1   2   3   4   5   6   7 µs

Position Encoding Magic

Aircraft positions are encoded using CPR (Compact Position Reporting) - an ingenious algorithm that represents global coordinates in just 17 bits each for latitude and longitude (vs. ~55 bits normally).

The README includes the complete CPR decoding algorithm with:

Zone calculations
Latitude/longitude recovery
NL (Number of Longitude zones) lookup tables
Even/odd frame pairing logic

Message Structure

Detailed breakdowns of every message type:

DF11: All-Call Reply (ICAO address announcement)
DF17: Extended Squitter (ADS-B position/velocity/ID)
DF4/DF5: Altitude and Identity Replies
DF20/DF21: Comm-B messages with BDS data

CRC & Error Correction

The decoder implements proper CRC-24 checking with:

Single-bit error correction (default)
Two-bit error correction (aggressive mode)
ICAO address recovery from XORed parity fields

Architecture

The codebase is clean and modular:

┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   RTL-SDR   │────►│ Demodulator │────►│   Decoder   │────►│  Aircraft   │
│   Input     │     │             │     │             │     │   Tracker   │
│             │     │ • Preamble  │     │ • CRC Check │     │             │
│ • 2 MHz IQ  │     │ • PPM Decode│     │ • DF Parse  │     │ • Position  │
│ • 8-bit     │     │ • Magnitude │     │ • CPR Decode│     │ • History   │
└─────────────┘     └─────────────┘     └─────────────┘     └─────────────┘

Key modules:

demodulator.rs - Preamble detection and PPM decoding
decoder.rs - Message parsing and field extraction
crc.rs - Error detection and correction
aircraft.rs - Position tracking and CPR decoding
network.rs - TCP/HTTP servers

Educational Value

While this is a production-ready tool, it's also an excellent learning resource:

Protocol Documentation: 60KB+ of detailed explanations, diagrams, and examples
Clean Rust Code: Idiomatic async Rust with tokio
Real-World DSP: Signal processing, demodulation, error correction
Network Programming: Concurrent TCP servers and HTTP APIs
Aviation Technology: Deep dive into Mode S/ADS-B standards

The README includes:

ASCII art diagrams of signal structures
Bit-level message breakdowns
Decoding algorithms with pseudocode
Lookup tables and encoding schemes
Examples with real messages

Future Enhancements

Some ideas I'm exploring:

Mode A/C decoding (older transponders)
MLAT (Multilateration) support
Database integration for aircraft info
Advanced filtering and alerting
Performance optimizations for embedded systems

Contributing

The project is open source and welcomes contributions! Whether it's:

Bug fixes
Performance improvements
Additional message types
Documentation enhancements
Testing on new hardware

Check out the repo: github.com/ktauchathuranga/adsb-rx

References

The implementation follows official specifications:

ICAO Annex 10 (Aeronautical Telecommunications)
DO-260B (MOPS for 1090 MHz ADS-B)
Mode S specifications
Various research papers on CPR decoding

Final Thoughts

Building this decoder taught me so much about:

Radio protocols and signal processing
The elegance of well-designed encoding schemes (CPR is brilliant!)
Real-time systems and performance optimization
The fascinating world of aviation technology

If you're interested in SDR, aviation, or just want to see what's flying overhead, give it a try! The hardware is cheap, the software is free, and watching aircraft appear on your screen in real-time is genuinely exciting.

Have questions? Drop them in the comments! I'd love to hear about your ADS-B setups or help troubleshoot any issues.

Like this? Consider giving the repo a star on GitHub!

rust #sdr #aviation #opensource #flightracking

Generate cloud-init files for Raspberry Pi OS without re-downloading images

Ashen Chathuranga — Wed, 24 Dec 2025 10:40:05 +0000

Introduction

Raspberry Pi recently introduced cloud-init support in their official Raspberry Pi OS images. This is a big step forward because cloud-init allows users to preconfigure devices before first boot, including Wi-Fi credentials, users, SSH access, locale, and more.

However, there is a practical problem with the current workflow provided by the official Raspberry Pi Imager. Advanced customization options are only available when you select Raspberry Pi OS from the official OS list inside the imager. If you instead flash a locally downloaded image using the Custom Image option, those configuration options disappear.

For users with limited bandwidth, slow connections, or frequent cache cleanups, this becomes frustrating very quickly.

This article explains the problem in detail and presents a simple, bandwidth-friendly solution using a cloud-init file generator.

The problem with Raspberry Pi Imager customization

1. Customization only works with official OS downloads

Raspberry Pi Imager allows you to configure:

Wi-Fi (SSID, password, country)
Username and password
SSH access
Locale, timezone, and keyboard layout

But these options are only enabled when:

You choose Raspberry Pi OS directly from the imager
The image is downloaded by the imager itself

If you:

Download the Raspberry Pi OS image manually
Use the Custom Image option to flash it

then all customization options are disabled.

2. Re-downloading wastes bandwidth

This creates several issues:

Raspberry Pi OS images are large
Clearing cache forces a full re-download
Re-downloading the same image multiple times wastes data
This is especially painful in regions with limited or expensive internet access

Many users already have the image they want, but still need a way to configure Wi-Fi and users before first boot.

How cloud-init works on Raspberry Pi OS

Recent Raspberry Pi OS images support cloud-init by reading configuration files from the boot partition during the first boot.

The key files are:

meta-data
network-config
user-data

If these files exist in the boot partition, Raspberry Pi OS will automatically apply the configuration on first boot.

This means:

No need for Raspberry Pi Imager customization
No need to re-download the OS image
Works with any flashing tool

You only need valid cloud-init files.

The solution: Raspberry Pi cloud-init generator

To solve this problem, I created a simple web-based tool that generates cloud-init files for Raspberry Pi OS.

Project overview

GitHub repository: https://github.com/ktauchathuranga/rpi-cloud-init-generator
Hosted website: https://rpi-cloud-init-generator.onrender.com/

This tool allows you to generate:

meta-data
network-config
user-data

ready to be copied directly to the Raspberry Pi boot partition.

How the workflow looks now

Old workflow (problematic)

Open Raspberry Pi Imager
Select Raspberry Pi OS from official list
Download the image again
Add customization
Flash SD card

Problems:

Repeated downloads
High data usage
Custom image option unusable

New workflow (efficient)

Download Raspberry Pi OS image once
Flash it using Custom Image in Raspberry Pi Imager or any other tool
Open the cloud-init generator website
Fill in Wi-Fi, user, and SSH details
Generate meta-data, network-config, and user-data
Copy these files to the boot partition of the SD card
Boot the Raspberry Pi

Result:

No re-downloads
Full cloud-init customization
Works offline after image download

Key benefits

Saves bandwidth
Avoids unnecessary re-downloads
Works with cached or archived images
Uses official Raspberry Pi OS cloud-init support
Simple and beginner-friendly

This approach is especially useful for:

Developers flashing multiple Raspberry Pi boards
Users with limited internet access
Automated or repeatable Raspberry Pi setups

Conclusion

Raspberry Pi OS cloud-init support is powerful, but the current Raspberry Pi Imager workflow unnecessarily forces users to re-download images to access basic customization features.

By generating cloud-init files manually and placing them in the boot partition, you can fully configure Raspberry Pi OS without relying on the imager’s official OS download flow.

The Raspberry Pi cloud-init generator makes this process simple, accessible, and bandwidth-efficient.

If you regularly work with Raspberry Pi boards, this approach can save both time and data while giving you full control over your system configuration.

Making Raspberry Pi Imager from AUR Work on Hyprland + Wofi

Ashen Chathuranga — Wed, 17 Dec 2025 10:02:17 +0000

Raspberry Pi Imager is the official tool for writing Raspberry Pi OS images (and other images) to SD cards or USB drives. While it works smoothly on traditional desktop environments, running it on Hyprland — a Wayland compositor — can be tricky, especially if installed via the AUR. Here’s a deep dive into the issue and how to fix it.

The Problem

On Arch Linux, you have two main ways to install Raspberry Pi Imager:

Pacman (official repo): sudo pacman -S rpi-imager
AUR (latest version): yay -S rpi-imager-latest

When using the AUR version:

Launching the app from wofi shows no response — the GUI doesn’t open.
Running from terminal works only with sudo -E rpi-imager.

Meanwhile, the Pacman version works normally from the menu.

Why This Happens

Root Privileges Needed

Raspberry Pi Imager requires access to devices (SD cards/USB drives), which normal users cannot access.
Therefore, it must run as root, usually via pkexec or sudo.

Wayland Environment

On Hyprland (Wayland), pkexec often fails silently if the environment variables (DISPLAY, WAYLAND_DISPLAY, XAUTHORITY) aren’t set properly.
The desktop file provided by the AUR package typically uses:

   Exec=pkexec --disable-internal-agent /usr/bin/rpi-imager %u

On Wayland, this does not carry over the environment, so the GUI never appears.

Desktop File Difference

The Pacman version (/usr/share/applications/org.raspberrypi.rpi-imager.desktop) works because its environment and paths are standard.
The AUR version may install to a slightly different path or not account for Wayland, causing the menu launcher to fail.

The Solution

The fix involves creating a wrapper script that preserves the Wayland environment and modifying the desktop file to use it.

Step 1: Create a Wayland-safe Wrapper

Create a new script at /usr/local/bin/rpi-imager-launch:

sudo nano /usr/local/bin/rpi-imager-launch

Paste the following:

#!/bin/bash
# Wayland-safe wrapper for Raspberry Pi Imager

export DISPLAY=$DISPLAY
export WAYLAND_DISPLAY=$WAYLAND_DISPLAY
export XAUTHORITY=$XAUTHORITY

# Launch Raspberry Pi Imager with pkexec
pkexec env DISPLAY=$DISPLAY WAYLAND_DISPLAY=$WAYLAND_DISPLAY XAUTHORITY=$XAUTHORITY /usr/bin/rpi-imager

Make it executable:

sudo chmod +x /usr/local/bin/rpi-imager-launch

Step 2: Modify the Desktop File

Edit the AUR-installed desktop file (likely /usr/share/applications/com.raspberrypi.rpi-imager.desktop):

sudo nano /usr/share/applications/com.raspberrypi.rpi-imager.desktop

Change the Exec line to:

Exec=/usr/local/bin/rpi-imager-launch %u

This ensures that when you click the app in wofi, the wrapper script runs, preserving the environment variables necessary for Wayland.

Step 3: Refresh the Menu

If necessary, refresh your desktop database:

update-desktop-database

Now, launching Raspberry Pi Imager from wofi works as expected — it will prompt for your password via GUI and open the application.

Why This Works

The wrapper ensures DISPLAY, WAYLAND_DISPLAY, and XAUTHORITY are correctly passed to pkexec, which is required on Wayland.
Modifying the desktop file allows the menu launcher to call the wrapper instead of the original binary directly.
This approach works for any root-required GUI application on Wayland that fails to launch from a menu.

Optional Enhancements

Passwordless Launch: You can configure sudoers to allow your user to run /usr/bin/rpi-imager without a password. This makes one-click launching possible but slightly reduces security.
Icon Customization: If the AUR version lacks an icon, you can download a PNG and set Icon=/path/to/icon.png in the desktop file.

Conclusion

Running AUR-installed Raspberry Pi Imager on Hyprland can fail silently due to Wayland environment issues with pkexec. The solution is simple:

Create a wrapper script that preserves environment variables.
Edit the desktop file to point to the wrapper.

This ensures wofi or any other menu launcher can start the app reliably, bridging the gap between Arch’s flexibility, Wayland, and applications requiring root access.

Why Square Waves Create Many Frequencies

Ashen Chathuranga — Sat, 13 Dec 2025 16:58:45 +0000

Understanding Digital Noise Using the Water Wave Analogy

1. The Core Confusion

A very common question in electronics is:

“If a square wave has one frequency, how does it create many other frequencies?”

At first glance, this feels contradictory. But the confusion comes from mixing up repetition rate with frequency content.

To make this intuitive, we’ll start with a water wave analogy, then slowly connect it to the real technical explanation.

2. The Water Wave Analogy

Calm Water

Imagine a perfectly calm lake. The surface is flat. Nothing is moving.

This is like DC voltage — no frequency at all.

Smooth Hand Motion → Single Frequency

Now gently move your hand up and down smoothly in the water.

What happens?

Clean, smooth waves
One dominant wave size
Predictable motion

This is like a sine wave:

Smooth voltage change
One frequency
Very little interference

Sudden Slap → Many Frequencies

Now instead of moving smoothly, slap the water once.

What do you see?

Large slow waves
Medium-sized ripples
Tiny fast ripples
Splashing in many directions

One single action created many wave sizes at the same time.

This is the key idea.

Sudden changes create many waves

Repeated Slaps → Square Wave

A square wave is like slapping the water repeatedly at a fixed rate:

SLAP   SLAP   SLAP   SLAP

Even if the slaps happen at a steady rhythm:

Each slap still creates
- slow waves
- fast ripples
- very fast ripples

So although the rate is fixed, the wave content is broad.

3. Translating the Analogy to Electronics

Repetition Rate vs Frequency Content

When we say:

"This is a 1 MHz square wave"

We are only talking about:

How often the wave repeats

Not what frequencies it contains.

Sharp Edges = Fast Change

A square wave looks like this:

_|‾|_|‾|_|‾|

Notice the instant vertical edges.

In physics:

Faster voltage change → higher frequencies

An instant edge means:

Infinite speed (theoretical)
Infinite frequency components (theoretical)

In reality, edges are limited — but still very fast.

4. The Technical Explanation (Fourier Concept)

Any repeating signal can be broken into sine waves.

A square wave is equivalent to:

Fundamental frequency (f)
3×f
5×f
7×f
9×f
… continuing upward

Example:

A 100 kHz square wave contains energy at:

100 kHz
300 kHz
500 kHz
700 kHz
900 kHz
into the MHz range

These are called harmonics.

5. Why Digital Devices Create Radio Noise

Raspberry Pi / Arduino Example

GPIO pins switch very fast
Output square waves
No built-in RF filtering

The connecting wires:

act like antennas
radiate the harmonics

This is exactly like water ripples spreading outward.

Why AM Radios Are Affected

AM radios:

detect amplitude changes
are sensitive to wideband noise

Square-wave harmonics fall directly into AM bands, causing:

buzzing
whining
clicking sounds

6. Why Sine Waves Are Clean

Signal Type	Edge Speed	Harmonics	RF Noise
Sine wave	Smooth	None	Very low
Triangle wave	Medium	Some	Medium
Square wave	Instant	Many	High

7. How Engineers “Calm the Water”

To reduce noise, engineers:

slow down edges
add RC filters
add capacitors near power pins
use ferrite beads
use shielding

In water terms:

Filters turn slaps into smooth hand movements

8. One-Sentence Summary

A square wave has one repetition rate, but its sharp edges force nature to include many frequencies — just like a water slap creates many ripples.

9. Memory Trick

Smooth motion → clean wave
Sudden motion → many waves

What Really Happens When You Turn On Your Phone (IMEI, Tower & Network Initialization Explained)

Ashen Chathuranga — Sat, 06 Dec 2025 14:13:11 +0000

This article explains exactly what happens from the moment you power on your phone until it gets full network access, including:

What data is sent to the tower
When the IMEI is transmitted
How authentication works
How telecom operators check millions of IMEI records instantly
How governments block unapproved devices (TRCSL / IMEI blacklisting)

1. Power-On: Baseband & RF Initialization

When you press the power button:

The baseband modem starts
RF transceiver activates
Precision clock (TCXO) starts
SIM interface powers up

At this point:

❌ No transmission
✅ Phone only listens to radio signals

2. Passive Cell Scanning (Silent Phase)

The phone scans supported frequency bands:

LTE Bands: 1, 3, 5, 8, etc.
Searches for:
- Synchronization Signals
- Broadcast channels (PBCH, BCCH)

From the tower it learns:

Operator name
Cell ID
Tracking Area Code (TAC)
Network capabilities

✅ Still anonymous

✅ No IMSI

✅ No IMEI

✅ No transmission yet

3. Cell Selection

The phone selects:

The strongest valid tower
That supports:
- Your SIM operator
- Your radio features

Now it decides:

"This is the tower I will register to."

4. First Transmission: RACH (Random Access)

Your phone sends its first uplink message:

Channel: RACH
Contains:
- Temporary timing
- Power parameters

❌ No IMEI

❌ No IMSI

✅ Still anonymous

The tower replies with timing alignment.

5. Network Attach Request (SIM Identity Begins)

Your phone sends an ATTACH REQUEST containing:

Field	Purpose
TMSI / IMSI	SIM identity
Device capabilities	LTE/5G features
Cipher algorithms	Encryption support

✅ IMSI involved

❌ IMEI still NOT sent

6. SIM Authentication & Encryption

Authentication challenge:


Tower → Random Challenge
SIM → Cryptographic Response

If verified:

Encryption keys are created
All traffic becomes encrypted

✅ SIM authenticated

✅ Secure channel established

7. IMEI Is Requested (Important Step)

Now the network sends:


IDENTITY REQUEST → IMEI

The phone replies:


IDENTITY RESPONSE → IMEI

Now the network finally knows:

Your hardware identity
Your exact device model
Your legal status

8. IMEI Validation Using EIR (Equipment Identity Register)

Network checks your IMEI against:

List	Meaning
✅ White List	Approved devices
⚠️ Grey List	Monitored devices
❌ Black List	Blocked devices

Result:

✅ Allowed → Full network service
❌ Blocked → "No Service / Emergency Only"

9. Does the Network Search Through 23 Million IMEIs One-by-One?

❌ Absolutely NOT.

Telecom operators use:

Hash tables
B-Tree indexes
In-memory caches
Distributed databases

Lookup process:


IMEI → Hash Index → Memory Lookup → Result in ~1–5 ms

Records	Lookup Time
1 million	~1 ms
10 million	~2–4 ms
30 million	~5 ms

✅ No scanning

✅ No looping

✅ No delays

10. Where the IMEI Database Exists

IMEI records exist in:

Central TRCSL EIR
Mirrored operator EIRs (Dialog, Mobitel, Airtel, Hutch)
Real-time synchronized systems

Your local operator checks its own cached EIR, not a remote server every time.

11. Final Network Activation

If everything is valid:

✅ Calls

✅ SMS

✅ Mobile Data

✅ Encrypted Communication

✅ IP Address Assigned

✅ Tower-to-tower handover enabled

12. Full Power-On Timeline

Stage	Time
RF Scan	~0.5 sec
Attach Request	~0.2 sec
SIM Auth	~0.3 sec
IMEI Check	~0.005 sec
IP Assignment	~0.2 sec

✅ Total: ~1–1.5 seconds

13. Network Type vs IMEI Checking Node

Network	IMEI Checked By
2G	MSC + VLR
3G	SGSN
4G LTE	MME
5G	AMF

14. Security Reality

In 2G, IMEI can be sniffed easily
In 4G/5G, IMEI is transmitted after encryption
That makes modern interception extremely difficult

15. Final Summary Diagram


Power On
↓
Scan Towers
↓
Attach with IMSI
↓
SIM Authentication
↓
Encrypted Channel
↓
IMEI Requested
↓
EIR Database Check (Milliseconds)
↓
Allowed ✅   or   Blocked ❌

16. Key Truth About Government Phone Blocking

❌ They do NOT hack your phone
❌ They do NOT modify firmware
❌ They do NOT disable WiFi
✅ They simply deny service at the network level using IMEI
✅ Your phone becomes a WiFi-only device if blocked

This article is ideal for:

Telecom engineering students
Cybersecurity researchers
Mobile device hackers & reverse engineers
RF & SDR learners
IMEI tracking & blacklisting research

My Command Reference

Ashen Chathuranga — Sat, 06 Sep 2025 06:04:37 +0000

Docker Commands

Container Management

# List all containers (running and stopped)
docker ps -a

# List only running containers
docker ps

# Stop all running containers
docker stop $(docker ps -q)

# Remove all stopped containers
docker rm $(docker ps -aq)

# Remove all containers (running and stopped)
docker rm -f $(docker ps -aq)

# Stop and remove a specific container
docker rm -f <container_name_or_id>

# Remove all unused containers, networks, images
docker system prune

# Remove everything including volumes
docker system prune -a --volumes

Image Management

# List all images
docker images

# Remove all unused images
docker image prune -a

# Remove specific image
docker rmi <image_name_or_id>

# Remove all images
docker rmi $(docker images -q)

# Build image from Dockerfile
docker build -t <tag_name> .

# Pull image from registry
docker pull <image_name>

Running Containers

# Run container interactively
docker run -it <image_name> /bin/bash

# Run container in background
docker run -d <image_name>

# Run with port mapping
docker run -p <host_port>:<container_port> <image_name>

# Run with volume mount
docker run -v <host_path>:<container_path> <image_name>

Logs and Debugging

# View container logs
docker logs <container_name_or_id>

# Follow logs in real-time
docker logs -f <container_name_or_id>

# Execute command in running container
docker exec -it <container_name_or_id> /bin/bash

# Inspect container details
docker inspect <container_name_or_id>

Arduino CLI Commands

Board Management

# Update board package index
arduino-cli core update-index

# Install board package (e.g., ESP32)
arduino-cli core install esp32:esp32

# List installed boards
arduino-cli core list

# List available boards
arduino-cli board listall

# Search for boards
arduino-cli core search <board_name>

Library Management

# Update library index
arduino-cli lib update-index

# Install library
arduino-cli lib install "<library_name>"

# List installed libraries
arduino-cli lib list

# Search for libraries
arduino-cli lib search <library_name>

# Uninstall library
arduino-cli lib uninstall "<library_name>"

Compilation and Upload

# Compile sketch
arduino-cli compile --fqbn <board_fqbn> <sketch_path>

# Upload to board
arduino-cli upload -p <port> --fqbn <board_fqbn> <sketch_path>

# Compile and upload in one command
arduino-cli compile --upload -p <port> --fqbn <board_fqbn> <sketch_path>

# Set upload speed (in sketch or command)
arduino-cli upload -p <port> --fqbn <board_fqbn> <sketch_path> --upload-field upload.speed=921600

Board Detection and Port Management

# List connected boards
arduino-cli board list

# Get board info
arduino-cli board details --fqbn <board_fqbn>

# Common FQBNs:
# Arduino Uno: arduino:avr:uno
# ESP32: esp32:esp32:esp32
# ESP8266: esp8266:esp8266:nodemcuv2

Serial Monitor with picocom

# Connect to serial port
picocom -b 115200 /dev/ttyUSB0

# Connect with different baud rates
picocom -b 9600 /dev/ttyUSB0
picocom -b 57600 /dev/ttyUSB0
picocom -b 921600 /dev/ttyUSB0

# Exit picocom: Ctrl+A then Ctrl+X

# List available serial ports
ls /dev/tty*
# or
dmesg | grep tty

Arduino IDE Configuration Files

# Preferences location (Linux)
~/.arduino15/

# Sketches default location
~/Arduino/

# Set upload speed in boards.txt or via IDE:
# Tools -> Upload Speed -> Select desired speed

Useful Arduino Compile Flags

# Verbose compilation output
arduino-cli compile --verbose --fqbn <board_fqbn> <sketch_path>

# Enable warnings
arduino-cli compile --warnings all --fqbn <board_fqbn> <sketch_path>

# Clean build
arduino-cli compile --clean --fqbn <board_fqbn> <sketch_path>

Linux commands | search

grep -rn "tozed_param" .

./etc/tozed/config_update:42:tozed_param=enabled

CPU Stress Test on Arch Linux

Ashen Chathuranga — Wed, 20 Aug 2025 18:57:30 +0000

This guide explains how to load your CPU to 100% to test cooling, thermal throttling, or stability.

⚠️ Warning

This will heat up your CPU significantly.
Monitor temperatures with lm_sensors.
Ensure your cooling system is working properly.
Do not leave unattended.

1. Install Required Tools

sudo pacman -Syu stress-ng lm_sensors

stress-ng → main stress-testing tool
lm_sensors → CPU temperature monitoring

Set up sensors:

sudo sensors-detect
sensors

2. Stress Test CPU

Option A: `stress-ng` (recommended)

Run all CPU cores at 100%:

stress-ng --cpu 0 --cpu-method matrixprod

--cpu 0 → use all cores
--cpu-method matrixprod → heavy floating-point load

Optional: stop automatically after 5 minutes:

stress-ng --cpu 0 --cpu-method matrixprod --timeout 5m

Option B: `yes` command (quick & dirty)

Each yes > /dev/null & consumes one core:

yes > /dev/null &
yes > /dev/null &
yes > /dev/null &
yes > /dev/null &
# Add one per CPU core

Stop all processes with:

killall yes

Option C: Compile Test (optional)

If you have source code:

make -j$(nproc)

-j$(nproc) → uses all CPU cores

3. Monitor CPU Temperature

watch -n 1 sensors

Updates every second
Check for thermal throttling warnings

4. Stop Stress Test

Ctrl + C if running in terminal
killall stress-ng or killall yes for background processes

mDNS Setup on Arch Linux

Ashen Chathuranga — Wed, 20 Aug 2025 14:06:13 +0000

This will let other devices on your local network access your machine using a hostname like:

http://archlinux.local:8080

instead of remembering the IP (192.168.x.x).

1. Install required packages

sudo pacman -S avahi nss-mdns

2. Enable and start Avahi

sudo systemctl enable --now avahi-daemon

3. Configure `/etc/nsswitch.conf`

Open /etc/nsswitch.conf with your favorite editor:

sudo nano /etc/nsswitch.conf

Replace its contents with this (copy and paste):

# Name Service Switch configuration file.
# See nsswitch.conf(5) for details.

passwd: files systemd
group: files [SUCCESS=merge] systemd
shadow: files systemd
gshadow: files systemd

publickey: files

hosts: files mdns_minimal [NOTFOUND=return] resolve [!UNAVAIL=return] dns myhostname
networks: files

protocols: files
services: files
ethers: files
rpc: files

netgroup: files

Save and exit.

4. Restart name resolution

sudo systemctl restart systemd-resolved

5. Test

On your Arch machine, run:

ping archlinux.local

You should see it resolve to your LAN IP (e.g., 192.168.3.224).

On another device (Linux/macOS/iOS), try opening:

http://archlinux.local:8080

DEV Community: Ashen Chathuranga

DevRank LK: Sri Lanka's GitHub Developer Leaderboard is Live – Join and Get Ranked! 🇱🇰

How the Ranking Works

Current Top 5 (as of today)

Why You Should Opt In Right Now

How to Join (Takes literally 2 minutes)

Let’s Grow This Together

SriLanka #developers #opensource #GitHub #DevRankLK #srilankantech #coding #community

Reviving Tech: Building OpenPager

What I Built with Google Gemini

Demo

What I Learned

Google Gemini Feedback

Introducing OpenPager: A POCSAG Transceiver Library for Arduino

The Hardware

Key Features

Installation

Usage: Receiving Messages

Usage: Transmitting Messages

Under the Hood

Links

SSTV Encoder With 10+ Modes

What I Built

Demo

My Experience with GitHub Copilot CLI

Complete ADS-B Decoder in Rust: Track Aircraft in Real-Time with RTL-SDR

What Can You Track?

Key Features

Complete Mode S Decoding

Smart Aircraft Filtering

Emergency Detection

Multiple Output Formats

Getting Started

Hardware You'll Need

Installation

Running It

How ADS-B Works

Signal Characteristics

Position Encoding Magic

Message Structure

CRC & Error Correction

Architecture

Educational Value

Future Enhancements

Contributing

References

Final Thoughts

rust #sdr #aviation #opensource #flightracking

Generate cloud-init files for Raspberry Pi OS without re-downloading images

Introduction

The problem with Raspberry Pi Imager customization

1. Customization only works with official OS downloads

2. Re-downloading wastes bandwidth

How cloud-init works on Raspberry Pi OS

The solution: Raspberry Pi cloud-init generator

Project overview

How the workflow looks now

Old workflow (problematic)

New workflow (efficient)

Key benefits

Conclusion

Making Raspberry Pi Imager from AUR Work on Hyprland + Wofi

The Problem

Why This Happens

The Solution

Step 1: Create a Wayland-safe Wrapper

Step 2: Modify the Desktop File

Step 3: Refresh the Menu

Why This Works

Optional Enhancements

Conclusion

Why Square Waves Create Many Frequencies

Understanding Digital Noise Using the Water Wave Analogy

1. The Core Confusion

2. The Water Wave Analogy

Calm Water

Smooth Hand Motion → Single Frequency

Sudden Slap → Many Frequencies

Repeated Slaps → Square Wave

3. Translating the Analogy to Electronics

Option A: `stress-ng` (recommended)

Option B: `yes` command (quick & dirty)

3. Configure `/etc/nsswitch.conf`