Decoding Digital Modes: I Found Hidden Data Streams in Radio Waves! 📡💻

Real talk: I was scanning the 20-meter ham radio band with my RTL-SDR when I heard the weirdest sound - not voices, not music, but digital chirps and warbling tones that sounded like a dying modem from 1995. My first thought: "What IS that noise?"

Then I ran it through FLDigi (digital mode decoder software), and suddenly my screen filled with TEXT. Real-time conversations between people across the world, transmitted as AUDIO through radio waves. My mind was BLOWN! 🤯

What I discovered: There's an entire HIDDEN layer of digital communication happening on RF bands. It's like discovering that radio waves carry network packets - except instead of Ethernet, the transport layer is SOUND WAVES modulated onto radio frequencies!

Welcome to digital modes - where developers and radio nerds unite to send data through the air! 📻

What Even Are Digital Modes? 🤔

Digital Modes = Data transmission using audio tones over radio

Translation: Instead of voice, computers generate specific audio patterns (tones, chirps, beeps) that encode text/data. Those sounds get transmitted via RF, received by another radio, and decoded back to text/data!

Think of it like this:

Traditional radio: Humans talk → microphone → RF transmitter → RF receiver → speaker → humans hear
Digital modes: Computer → audio tones → RF transmitter → RF receiver → audio decode → computer displays text! 💻

What blew my mind: It's basically a modem... but instead of phone lines, the transport is RADIO WAVES! We're doing TCP/IP-style communication over electromagnetic frequencies! 🌊

How I Discovered Digital Modes (Down the Rabbit Hole) 🐰

Week 1: The Mysterious Sounds

Me with RTL-SDR: Scanning 14.070 MHz

Audio output: "BLEEP BLOOP WARBLE CHIRP EEEEEE WARBLE WARBLE"

Me: "Is my radio broken? What is this garbage?" 😕

Ham radio friend: "That's PSK31! People are having conversations right now!"

Me: "WHAT?! How do I decode it?!"

Week 2: First Successful Decode

In my RF experiments, I installed FLDigi and pointed it at the audio from my SDR:

# Route RTL-SDR audio to FLDigi on Linux
rtl_fm -f 14.070M -M usb -s 12k - | aplay &

# Open FLDigi, select PSK31 mode, click "Start"

What appeared on screen:

CQ CQ CQ DE N7ABC N7ABC K
N7ABC DE W1XYZ W1XYZ PSE K
W1XYZ DE N7ABC GM BOB TNX FER CALL UR RST 599 599 NAME BOB BOB QTH SEATTLE WA HW? K

My reaction: "THEY'RE HAVING A CONVERSATION! I'M READING TEXT FROM RADIO WAVES!" 🎉

What fascinated me as a developer: This is ASYNCHRONOUS MESSAGE PASSING over RF! They're literally using radio as a transport layer for text protocol! It's like IRC over shortwave! 📡

Week 3: The Deep Dive Into Modes

I discovered there are DOZENS of digital modes:

Keyboard-to-keyboard modes (real-time chat):

PSK31 (Phase Shift Keying, 31 baud)
RTTY (Radioteletype, from the 1960s!)
MFSK (Multiple Frequency Shift Keying)
Olivia (super robust, works in terrible conditions)

Automated weak-signal modes:

FT8 (15-second time slots, works 20dB below noise!)
FT4 (faster 7.5-second version)
JT65 (even weaker signals)
WSPR (Weak Signal Propagation Reporter - beacon mode)

Specialized modes:

SSTV (Slow Scan TV - transmit IMAGES!)
Packet Radio (like TCP/IP over RF!)
Winlink (email over HF radio!)
D-STAR, DMR, Fusion (digital voice)

My "aha!" moment: Each mode is like a different network protocol! Some optimize for speed, some for reliability, some for weak signals. It's protocol engineering for RADIO! 🎯

My First Digital Mode: PSK31 Deep Dive 📻

What Is PSK31?

PSK31 = Phase Shift Keying at 31.25 baud

How it works:

Text characters encoded as binary
Binary modulates audio tone phase (0° or 180°)
Audio tone sent through radio transmitter
Receiver decodes phase shifts back to binary → text!

Bandwidth: Only 31.25 Hz! (You can fit 100+ PSK31 signals in a normal voice channel!)

What I love about it: It's TINY bandwidth, works with low power, and sounds like R2-D2 having a conversation! 🤖

My First PSK31 Decode Session

Setup:

RTL-SDR ($25)
Dipole antenna I built for $5
FLDigi software (FREE!)
Tuned to 14.070 MHz (20m PSK31 calling frequency)

What I saw:

# FLDigi waterfall display shows DOZENS of signals:

[Waterfall display - imagine colored vertical lines representing PSK signals]

Signal 1: 14.070.150 MHz
Signal 2: 14.070.250 MHz
Signal 3: 14.070.500 MHz
... [50+ signals in just 3 kHz!]

Decoded text from Signal 1:

CQ CQ CQ DE IZ2XYZ IZ2XYZ PSE K
IZ2XYZ DE VE3ABC VE3ABC GM MARIO PSE K
VE3ABC DE IZ2XYZ GM DAVE TNX CALL UR RST 599 599 NAME MARIO MARIO QTH ROME ITALY HW? K
VE3ABC DE IZ2XYZ FB DAVE UR RST 599 NAME DAVE QTH TORONTO CANADA RIG IC-7300 ANT DIPOLE @ 30FT WX CLOUDY 5C HW? K

Translation (for non-hams):

CQ = "Calling any station"
DE = "From" (this is...)
PSE = Please
K = "Over" (your turn)
RST = Signal report (Readability, Strength, Tone)
QTH = Location
RIG = Radio equipment
ANT = Antenna
WX = Weather
FB = "Fine Business" (excellent!)

What blew my mind: I'm reading a conversation between Italy and Canada, happening RIGHT NOW, transmitted as phase-modulated audio tones at 50 characters per minute! 🌍

FT8: The Mode That Changed Everything ⚡

What Makes FT8 Special?

FT8 = Franke-Taylor 8-FSK mode

Developed by Nobel Prize winner Joe Taylor (K1JT) for weak signal work. It's REVOLUTIONARY!

Key features:

15-second time slots (synchronized to UTC!)
50 Hz bandwidth (incredibly narrow!)
Works 20 dB below noise floor (signals you can't even HEAR!)
Automated computer operation (QSO in 4 transmissions!)
Structured message format (callsign, grid square, signal report)

What this means: You can make contacts with 5 watts that would need 500 watts with voice! 💪

My First FT8 Contact (It Was MAGICAL!)

Setup:

RTL-SDR (receive only)
WSJT-X software (FREE!)
Tuned to 14.074 MHz (20m FT8)
GPS-synchronized system clock (critical!)

What happened:

# WSJT-X interface shows:

Time    dB   DT Freq   Message
──────────────────────────────────────────
234500  -15  0.2 1234  CQ DX VK3XYZ QF22
234515  -18  0.4 1567  CQ NA W1ABC FN42
234530  -12  0.1 2134  CQ JA7XYZ PM96
234545  -22 -0.2  876  CQ EU G4XYZ IO91

# That's FOUR continents in 60 seconds! 🌎

How an FT8 contact works:

TX1: CQ W1ABC FN42              # Me calling CQ
RX1: W1ABC VK3XYZ QF22          # Australian station replies
TX2: VK3XYZ W1ABC -12           # I send signal report (-12 dB)
RX2: W1ABC VK3XYZ R-15          # He confirms, sends his report
TX3: VK3XYZ W1ABC RRR           # I confirm receipt
RX3: W1ABC VK3XYZ 73            # He says goodbye

Total time: 90 seconds
Distance: 10,000 miles
Power: 5 watts
Result: CONTACT MADE! 🎯

What fascinated me: It's a TIME-SYNCHRONIZED PROTOCOL! Every transmission starts at :00, :15, :30, :45 seconds past the minute. If your system clock is off by >2 seconds, it WON'T DECODE! It's like NTP meets DSP meets ham radio! ⏰

The Software Developer's Guide to Digital Modes 💻

Why Developers Love Digital Modes

Reason #1: It's Basically Protocol Engineering

Each digital mode is a different PROTOCOL with trade-offs:

PSK31: Low bandwidth, human-readable, real-time
RTTY: Legacy protocol (1960s!), still used
FT8: Ultra-weak signal, automated, structured
Olivia: Error correction, works in noise/interference
Packet Radio: LITERALLY IP packets over RF!

As a software developer exploring digital modes, I realized: This is network engineering, but the OSI layers are DIFFERENT! 📊

Traditional:        Digital Radio:
─────────────       ──────────────
Application         Text/Data
Transport (TCP)     Mode protocol (FT8, PSK31, etc.)
Network (IP)        (N/A - point to point)
Data Link           Audio encoding
Physical            RF transmission!

Reason #2: Open Source Everything!

Every major digital mode has open-source implementations!

My favorite software:

# FLDigi - Multi-mode digital decoder
sudo apt-get install fldigi

# WSJT-X - FT8, FT4, JT65 (by K1JT)
sudo apt-get install wsjtx

# Direwolf - Packet radio TNC
git clone https://github.com/wb2osz/direwolf

# Fldigi - PSK31, RTTY, MFSK, Olivia, etc.
# Source: http://www.w1hkj.com/

What I learned: The source code is FASCINATING! Signal processing, error correction, modulation/demodulation - it's CS theory in practice! 🎓

Reason #3: You Can WRITE Your Own Modes!

Mind-blowing discovery: Ham radio rules allow EXPERIMENTAL modes!

My custom mode experiment:

# Simple FSK (Frequency Shift Keying) mode
import pyaudio
import numpy as np

def generate_fsk(text, freq_mark=1000, freq_space=1200, baud=45):
    """
    Generate FSK audio from text
    Mark (1) = freq_mark Hz
    Space (0) = freq_space Hz
    """
    sample_rate = 48000
    samples_per_bit = sample_rate // baud

    audio = []
    for char in text:
        # Convert char to binary
        bits = format(ord(char), '08b')

        for bit in bits:
            freq = freq_mark if bit == '1' else freq_space
            # Generate sine wave for this bit
            t = np.linspace(0, 1/baud, samples_per_bit)
            samples = np.sin(2 * np.pi * freq * t)
            audio.extend(samples)

    return np.array(audio, dtype=np.float32)

# Encode message
message = "CQ CQ CQ DE AI1XYZ K"
audio_signal = generate_fsk(message)

# Play through audio interface (which feeds radio transmitter)
# Receiver decodes the FSK tones back to text!

Result: I transmitted my own custom protocol! Granted, it's just basic FSK, but the point is: YOU CAN BUILD THIS! 🔨

Practical Digital Mode Projects I Built 🚀

Project 1: FT8 Auto-Logger with Database

The idea: Log all FT8 contacts automatically to a database

What I built:

import sqlite3
import subprocess
import re
from datetime import datetime

# Watch WSJT-X log file
LOG_FILE = "~/.local/share/WSJT-X/ALL.TXT"

def parse_ft8_line(line):
    """
    Parse FT8 log line:
    234500  -15  0.2 1234  CQ W1ABC FN42
    """
    match = re.match(r'(\d{6})\s+(-?\d+)\s+(-?\d+\.\d+)\s+(\d+)\s+(.*)', line)
    if match:
        time, db, dt, freq, message = match.groups()
        return {
            'timestamp': datetime.strptime(time, '%H%M%S'),
            'snr': int(db),
            'dt': float(dt),
            'freq': int(freq),
            'message': message
        }
    return None

# Set up database
conn = sqlite3.connect('ft8_log.db')
cursor = conn.cursor()
cursor.execute('''
    CREATE TABLE IF NOT EXISTS contacts (
        id INTEGER PRIMARY KEY,
        timestamp DATETIME,
        callsign TEXT,
        grid TEXT,
        snr INTEGER,
        frequency INTEGER,
        band TEXT
    )
''')

# Tail the log file and insert new contacts
# (Implementation left as exercise - use 'tail -f' or watchdog library)

Result: A searchable database of ALL my FT8 contacts! I can query "show me all contacts from Japan" or "contacts made with <-20 dB SNR" 📊

Project 2: PSK31 Spectrum Analyzer

The goal: Visualize ALL PSK31 signals in the band

What I built:

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
from rtlsdr import RtlSdr

# Initialize RTL-SDR
sdr = RtlSdr()
sdr.sample_rate = 2.4e6
sdr.center_freq = 14.070e6  # 20m PSK31
sdr.gain = 'auto'

# Capture samples
samples = sdr.read_samples(256*1024)

# Compute FFT (frequency spectrum)
fft = np.fft.fft(samples)
freq = np.fft.fftfreq(len(samples), 1/sdr.sample_rate)

# Plot waterfall
plt.figure(figsize=(12, 6))
plt.specgram(samples, NFFT=1024, Fs=sdr.sample_rate, Fc=sdr.center_freq)
plt.xlabel('Time (s)')
plt.ylabel('Frequency (MHz)')
plt.title('PSK31 Waterfall - 20m Band')
plt.colorbar(label='Power (dB)')
plt.show()

Result: A beautiful waterfall display showing ALL active PSK31 signals! It's like network packet capture, but for RADIO! 🌊

Project 3: Automatic APRS Decoder

APRS = Automatic Packet Reporting System

It's literally IP-like packets over VHF radio! Position reports, weather data, messages!

My setup:

# Use Direwolf as software TNC (Terminal Node Controller)
direwolf -c config.conf

# Direwolf decodes APRS packets and outputs:
# [0] W1ABC>APRS,WIDE1-1:=4240.50N/07130.50W-PHG5360 Boston, MA
# [0] Position: 42°40.50'N 71°30.50'W
# [0] Comment: Boston, MA

# Feed to aprs.fi or local database

What I discovered: APRS packets contain GPS coordinates, altitude, speed, weather, messages - all transmitted as 1200 baud AFSK (Audio Frequency Shift Keying) on 144.390 MHz! 🗺️

Project 4: SSTV Image Decoder

SSTV = Slow Scan TV

Transmit IMAGES via audio tones! Used by astronauts on ISS!

My first decode:

# On Linux
sudo apt-get install qsstv

# Tune RTL-SDR to 14.230 MHz (20m SSTV)
# Route audio to QSSTV
# When SSTV transmission detected:
# → Image slowly appears line by line! 🖼️

What I received: Pictures from ham operators worldwide! Shack photos, QSL cards, antenna pics, even CAT PHOTOS sent via radio! 😹

The physics: An image is scanned line by line, converted to analog brightness values, transmitted as frequency-modulated audio tones, then reconstructed! It's like fax machines, but over ham radio!

The Signal Processing Magic Behind Digital Modes 🔬

How Demodulation Actually Works

Basic process:

RF Signal → SDR → IQ Samples → Audio → Digital Mode Decoder → Text!

What happens in detail:

RF Reception: SDR receives radio signal at specific frequency (e.g., 14.070 MHz)
Downconversion: SDR converts RF to baseband IQ samples (complex numbers!)
Filtering: Remove out-of-band noise, isolate signal
Demodulation:
- For PSK: Detect phase changes (0° vs 180°)
- For FSK: Detect frequency shifts (mark vs space)
- For MFSK: Detect which of N frequencies is active
Symbol → Bit conversion: Phase/frequency patterns → binary data
Error correction: Apply FEC (Forward Error Correction) if mode supports it
Character decode: Binary → ASCII text!

What fascinated me: Each mode is optimized for different conditions! PSK31 for stable channels, FT8 for weak signals with time sync, Olivia for heavy noise/interference! 🎯

The Math (Simplified!)

PSK31 phase detection:

# Simplified PSK31 demodulator concept
import numpy as np

def detect_phase_shift(audio_samples, carrier_freq, sample_rate):
    """
    Detect 180° phase shifts in audio (mark/space)
    """
    # Generate reference carrier
    t = np.arange(len(audio_samples)) / sample_rate
    carrier = np.exp(2j * np.pi * carrier_freq * t)

    # Mix with received signal (complex multiplication)
    mixed = audio_samples * carrier

    # Low-pass filter to get baseband
    # (implementation omitted - use scipy.signal.butter)

    # Detect phase changes
    phase = np.angle(mixed)
    phase_diff = np.diff(phase)

    # Phase shifts near π (180°) = binary '1'
    # Phase shifts near 0 = binary '0'
    bits = (np.abs(phase_diff) > np.pi/2).astype(int)

    return bits

FT8 synchronization:

# FT8 uses Costas arrays for time/frequency sync!
# Each transmission starts with sync tones
# Receiver cross-correlates to find exact timing

def find_ft8_sync(audio, sample_rate):
    """
    Detect FT8 sync pattern (simplified)
    """
    # FT8 sync is a 7x7 Costas array
    # Generates distinctive frequency-hop pattern
    # Receiver searches for this pattern

    # ... complex DSP omitted ...
    # Returns: (time_offset, frequency_offset)
    pass

What I learned: Digital modes are APPLIED SIGNAL PROCESSING! Fourier transforms, filters, correlation, modulation theory - it's all here! 📐

Common Digital Mode Mistakes (I Made ALL of These!) 🙈

Mistake #1: System Clock Not Synchronized

The problem: FT8 requires precise timing (<±2 seconds)

What happened: My contacts wouldn't decode. Spent 2 hours debugging before realizing my system clock was 5 seconds off! 😅

The fix:

# Install NTP (Network Time Protocol)
sudo apt-get install ntp

# Or use systemd-timesyncd
sudo timedatectl set-ntp true

# Verify sync
timedatectl status
# Should show: "System clock synchronized: yes"

Lesson: Time synchronization matters! FT8 is like a TDMA protocol - wrong timing = no decode! ⏰

Mistake #2: Wrong Audio Routing

My error: FLDigi was listening to the wrong audio device

Symptoms: Waterfall display was flat, no signals decoded

The fix:

# List audio devices
aplay -l

# Route RTL-SDR audio correctly
rtl_fm -f 14.070M -M usb -s 12k - | aplay -D plughw:0,0

Pro tip: Use PulseAudio or pavucontrol to visually route audio! 🔊

Mistake #3: Ignoring Doppler Shift on Satellites

What happened: Tried decoding ISS SSTV, image was distorted

Why: Satellites move fast! Frequency shifts due to Doppler effect!

The fix: Use Gpredict software to track satellite and apply Doppler correction! 🛰️

Mistake #4: Too Much RF Gain

The problem: SDR gain set to maximum = overload!

Result: Signals were clipped, decoding failed

The fix: Reduce gain until waterfall shows clean signals without saturation

Rule of thumb: Start with gain=20-30, adjust until signal is visible but not clipping! 📶

Legal & Ethical Considerations ⚖️

What's Legal (For Receiving)

With RTL-SDR (receive-only):

✅ Receive ANY digital mode (no license needed!)
✅ Decode ham radio, weather satellites, APRS
✅ Listen to all amateur radio digital modes
✅ Educational experimentation
✅ Building decoders and analyzing signals

What I do: Receive-only monitoring with RTL-SDR. No license required! 📻

What Requires a License (For Transmitting)

To TRANSMIT digital modes:

❌ Need amateur radio license (Technician or higher)
❌ Must identify with callsign
❌ Follow band plan and power limits
❌ Use only authorized modes on allowed frequencies

Important: All my transmitting experiments require my ham license (General class)! Get licensed before transmitting! 📞

Encryption Rules

In amateur radio (US FCC Part 97):

❌ NO ENCRYPTION allowed (with few exceptions)
✅ Error correction codes OK (FEC)
✅ Compression OK
❌ Obscuring message content NOT OK

Why: Amateur radio is for open experimentation and emergency communications. Encrypted messages defeat that purpose!

Exception: Commercial/government services can use encryption, but those require special licenses!

Resources That Helped Me Learn 📚

Software (All FREE!)

Decoders:

FLDigi: PSK31, RTTY, MFSK, Olivia, etc. (http://www.w1hkj.com/)
WSJT-X: FT8, FT4, JT65 (https://physics.princeton.edu/pulsar/k1jt/wsjtx.html)
QSSTV: Slow Scan TV (http://users.telenet.be/on4qz/)
Direwolf: Packet radio TNC (https://github.com/wb2osz/direwolf)

Analysis:

Audacity: Audio analysis (visualize modulation!)
GNU Radio: Visual signal processing
Inspectrum: RF recording analysis

Books

"Digital Modes for All Occasions" by Murray Greenman (ZL1BPU) - BEST beginner book!
"The ARRL Guide to Digital Modes" - Comprehensive reference
"Understanding Digital Signal Processing" by Richard Lyons - The math behind it all

Online Resources

Websites:

PSK31 Homepage: http://aintel.bi.ehu.es/psk31.html
Joe Taylor's WSJT Page: https://physics.princeton.edu/pulsar/k1jt/
Packet Radio Info: http://www.tapr.org/
sigidwiki.com: Identify mystery digital signals!

YouTube Channels:

Ham Radio Crash Course: Digital modes tutorials
w2aew: Signal processing deep dives
Dave Casler (KE0OG): FT8 tutorials

Communities

Forums:

r/amateurradio: Helpful for digital mode questions!
r/RTLSDR: SDR + digital modes
PSK31 Yahoo Group: Active PSK community
WSJT Group: FT8/FT4 discussions

Real-time:

PSKReporter.info: See live FT8/PSK31 propagation!
APRS.fi: Live APRS packet tracking worldwide! 🌍

The Bottom Line 💡

Digital modes are where software development meets radio frequency. You're literally writing/debugging PROTOCOLS that run over electromagnetic waves!

What I learned as a software developer exploring digital modes:

✅ Each mode is a different protocol with trade-offs
✅ Signal processing is applied CS theory
✅ You can build your own modes (with ham license!)
✅ Open-source software dominates the space
✅ Time synchronization is CRITICAL (FT8)
✅ Error correction lets weak signals through
✅ It's networking over radio waves! 📡

The best part: Digital modes feel like "native territory" for developers. We understand protocols, state machines, encoding, error correction. It's less "learn radio" and more "apply what you already know to a new medium!" 💻

After weeks of digital mode experiments, my takeaway: Radio isn't just voice and music. There's an entire DIGITAL universe happening on RF bands - data, text, images, packets - all transmitted as audio tones through electromagnetic waves. Welcome to the invisible internet! 🌐

Your Weekend Digital Mode Project 🚀

Saturday Morning: Setup (2 hours)

Install software:

# On Linux
sudo apt-get install fldigi wsjtx

# On Windows/Mac
# Download from official sites

Get RTL-SDR working:

# Test reception
rtl_fm -f 14.070M -M usb -s 12k - | aplay

Sync system clock:

sudo timedatectl set-ntp true

Saturday Afternoon: First Decodes (3 hours)

PSK31 receiving:

Launch FLDigi
Set mode to PSK31
Tune to 14.070 MHz
Watch text appear! 📝

FT8 receiving:

Launch WSJT-X
Set mode to FT8
Tune to 14.074 MHz
Enable "Auto-Seq" if you have TX capability
Watch contacts from around the world! 🌍

Sunday: Advanced Experiments (4 hours)

Project ideas:

Log all FT8 contacts to database
Build PSK31 spectrum analyzer
Decode SSTV images
Try Olivia mode (works in terrible conditions!)
Experiment with APRS packet decoding
Build your own simple FSK decoder! 🔨

Your Action Plan Right Now 🎯

Today:

Download FLDigi and WSJT-X
Test RTL-SDR on 14.070 MHz (PSK31)
Join r/amateurradio and r/RTLSDR
Watch one digital modes tutorial on YouTube

This Week:

Decode your first PSK31 conversation
Set up FT8 and watch global contacts
Sync your system clock with NTP
Try 3+ different digital modes

This Month:

Build a digital mode logger
Get your ham license (to transmit!)
Make your first FT8 contact
Explore SSTV, APRS, and packet radio
Contribute to open-source digital mode projects! 🚀

Final Thoughts 💭

When I started exploring RF, I thought it was all about antennas and radios. Then I discovered digital modes and realized: Radio waves can carry DATA, not just voice!

It's like discovering a parallel internet that runs over electromagnetic frequencies instead of fiber optics. There are protocols, error correction, packet routing (APRS), even email (Winlink)!

Best parts of digital modes:

✅ Perfect for developers (it's all protocols!)
✅ Open-source software ecosystem
✅ You can receive with $25 RTL-SDR
✅ Make worldwide contacts with 5 watts
✅ It's data networking over AIR WAVES!
✅ Endlessly hackable and experimental! 🔧

The moment I was hooked: I decoded my first FT8 contact - signal was -20 dB (below the noise floor!), but the computer pulled it out perfectly. I made a contact with Japan using 5 watts and a wire antenna. The signal traveled 6,000 miles, arrived weaker than thermal noise, and STILL decoded perfectly!

That's when I realized: Digital modes are MAGIC. We're doing the impossible - transmitting data through hostile RF environments using clever math and signal processing! 🎩✨

Ready to decode digital modes? Connect with me on LinkedIn and share your first digital mode decode!

Want to see my projects? Check out my GitHub - I've got FT8 loggers, PSK decoders, and custom mode experiments!

Now go forth and discover the hidden digital universe in radio waves! Welcome to digital modes - where bits meet hertz! 📡💻✨

P.S. The first time you decode a FT8 signal that's 20 dB below the noise floor (literally inaudible!), you'll understand why digital modes are incredible. Error correction and DSP magic letting data through when voice would be completely unintelligible! 🪄

P.P.S. If you become obsessed with FT8 and start checking PSKReporter every hour to see your signal propagation reach new countries, welcome to the club. I've worked 93 countries in 6 months with 5 watts. Digital modes are ADDICTIVE! 😄

P.P.P.S. The rabbit hole goes deep. First it's receiving PSK31. Then FT8. Then you get a ham license and start TRANSMITTING. Then you're writing custom digital mode decoders in Python. Then you're contributing to GNU Radio. Then you're publishing papers on novel modulation schemes. Ask me how I know! The intersection of software and RF is TOO COOL to stop! 🚀