Basic Radio Concepts

Flynn · Oct 1, 2025

Good question

Morse code isn’t assigned to just one band or frequency — it shows up across multiple radio services, mainly in ham (amateur) radio HF bands and sometimes in aviation and navigation beacons.

1. Amateur Radio Morse (CW) Bands

Ham operators call Morse “CW” (continuous wave).
Each HF band has a segment reserved for CW/Morse:

Band (Ham HF)	CW / Morse Code Range (approx.)
160 m	1.800 – 1.850 MHz
80 m	3.500 – 3.600 MHz
40 m	7.000 – 7.125 MHz
30 m	10.100 – 10.150 MHz (CW only worldwide)
20 m	14.000 – 14.070 MHz
17 m	18.068 – 18.095 MHz
15 m	21.000 – 21.070 MHz
12 m	24.890 – 24.930 MHz
10 m	28.000 – 28.070 MHz

These are the classic Morse hangouts. If you tune your dongle with CW mode (USB/LSB with narrow ~500 Hz filter) you’ll hear the “dits and dahs.”

2. Aviation & Navigation

NDBs (Non-Directional Beacons):
Found between 190 – 535 kHz, each beacon transmits its 2–3 letter ID in Morse.
VOR/ILS stations: Sometimes include Morse IDs around 108–118 MHz in the airband.

3. Military & Utility

Many shortwave utility stations (3–30 MHz) still use CW for identifiers, numbers stations, or training exercises.
You’ll sometimes stumble on mysterious CW beacons around 10–12 MHz and 20–30 MHz.

Bottom line:

For ham Morse, try 7.000–7.050 MHz (40m band) or 14.000–14.070 MHz (20m band). These are very active worldwide.
For aviation beacons, scan 190–535 kHz and listen for slow repeating letters.

Do you want me to give you exact SDR settings (mode, bandwidth, sample rate) so you can try decoding ham Morse on your dongle right now?

Flynn · Oct 1, 2025

So can I use a raspberry pi 5 and have an onboard webpage with buttons and the operator hit the buttons and instructions or text are converted to morse and sent and the raspberry pi 5 has a dongle and receives it. Can the raspberry pi run the software?

ChatGPT said:

Thought
Short answer: yes—the Raspberry Pi 5 is plenty powerful to host a local webpage with buttons, convert text to Morse (CW), and key a radio. Your RTL-SDR dongle can handle receive-only. For transmit you still need a proper RF transmitter (ham transceiver or SDR capable of TX) and a ham license. The Pi will “key” the rig via a GPIO-driven optocoupler (safe isolation), or you can use Hamlib/CAT for PTT. Receiving/decoding CW on the Pi works great with fldigi (headless) feeding text back into your web UI.
Below is a complete, minimal project you can drop on a Pi 5. It gives you:

A Flask web app with buttons (“CQ”, “TEST”, “Send Text”) and WPM control
A Morse encoder
A precise GPIO keyer (pigpio) to key a transmitter’s KEY jack
Optional integration points for Hamlib (rigctld) and fldigi CW-decode

Architecture (conceptual)

Browser → Flask endpoints → Morse encoder → GPIO keyer → Keys your radio (in CW mode)
(Optional RX) Radio audio → USB sound card → fldigi (headless) → HTTP poll → shows decoded text in the web UI
RTL-SDR: useful for spectrum/waterfall and to hear your own sidetone/spot signal; it does NOT transmit

File list (you asked to list all code file names)

README.md
requirements.txt
app.py
morse.py
keyer.py
templates/index.html
static/main.js
static/styles.css
(optional) rig.py // Hamlib helper (stubbed for now)
(optional) services/fldigi_client.py // pulls decoded CW from fldigi XML-RPC

README.md

Purpose: setup, wiring, and ops.

Hardware

Raspberry Pi 5
Optocoupler (e.g., PC817) + 1k resistor to isolate Pi GPIO from radio KEY jack
Pi GPIO pin → resistor → optocoupler LED (with Pi GND return); optocoupler transistor → radio KEY jack (observing radio’s key line polarity); never tie rig directly to GPIO.
Radio in CW mode; you do NOT need PTT for pure CW keying (use the KEY input).
For RX decoding: USB soundcard from radio’s audio out → fldigi.

Legal

Transmitting on amateur bands requires at least a Technician Class FCC license. RTL-SDR is RX-only.

Software (Pi OS)

sudo apt update && sudo apt install -y python3-pip python3-venv pigpio nginx
sudo systemctl enable pigpiod && sudo systemctl start pigpiod
(Optional CW decode) sudo apt install -y fldigi
(Optional rig control) sudo apt install -y hamlib
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
FLASK_APP=app.py flask run --host=0.0.0.0 --port=5000
Browse to http://<pi-ip>:5000

Optional integrations

fldigi: run fldigi with XML-RPC enabled (Configure → Misc → NBEMS / XML-RPC). Set mode CW. The app can poll decoded text (see services/fldigi_client.py).
rigctld: rigctld -m <model> -r <port> -s <baud> & (then use rig.py to set frequency/mode/PTT if you want).

Operating

Set WPM in the UI, enter text, click “Send”. The GPIO goes high/low to form dits/dahs and letter/word spacing at precise timing.

requirements.txt

Flask==3.0.0
pigpio==1.78

morse.py (Morse mapping + timing)

// Encodes ASCII to CW elements and computes precise timing from WPM
import re

ITU standard timing:

dit = 1200 / wpm (ms)

dah = 3 * dit

intra-element gap = dit

inter-letter gap = 3 * dit

inter-word gap = 7 * dit

MORSE_TABLE = {
'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..',
'E': '.', 'F': '..-.', 'G': '--.', 'H': '....',
'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..',
'M': '--', 'N': '-.', 'O': '---', 'P': '.--.',
'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-',
'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-',
'Y': '-.--', 'Z': '--..',
'0': '-----', '1': '.----', '2': '..---', '3': '...--',
'4': '....-', '5': '.....', '6': '-....', '7': '--...',
'8': '---..', '9': '----.',
'.': '.-.-.-', ',': '--..--', '?': '..--..', '/': '-..-.',
'=': '-...-', '+': '.-.-.', '-': '-....-', '@': '.--.-.',
'(': '-.--.', ')': '-.--.-', ':': '---...', ';': '-.-.-.',
'!': '-.-.--', ''': '.----.', '"': '.-..-.'
}
def sanitize_text(s: str) -> str:
# Uppercase, collapse whitespace to single spaces
s = re.sub(r'\s+', ' ', s.strip().upper())
return s
def text_to_morse(text: str):
text = sanitize_text(text)
words = text.split(' ')
encoded_words = []
for w in words:
letters = []
for ch in w:
if ch in MORSE_TABLE:
letters.append(MORSE_TABLE[ch])
# Ignore unsupported chars silently
encoded_words.append(letters)
return encoded_words # list of words, each is list of letter strings like ".-"
def dit_ms(wpm: int) -> int:
wpm = max(5, min(50, int(wpm)))
return int(1200 / wpm)

keyer.py (GPIO keying with accurate timing using pigpio)

// Drives a GPIO pin high/low to form dits/dahs with proper gaps.
import time
import pigpio
class CWKeyer:
def init(self, gpio_pin: int, wpm: int = 20, active_high: bool = True):
self.pi = pigpio.pi()
if not self.pi.connected:
raise RuntimeError("pigpio daemon not running. Start with: sudo systemctl start pigpiod")
self.gpio = gpio_pin
self.active_high = active_high
self.set_wpm(wpm)
self.pi.set_mode(self.gpio, pigpi

UTPUT)
self.key_up()

Code:

def set_wpm(self, wpm: int):
    self._dit_ms = max(24, int(1200 / max(5, min(50, int(wpm)))))  # clamp WPM 5..50
    self._dah_ms = 3 * self._dit_ms

def key_down(self):
    self.pi.write(self.gpio, 1 if self.active_high else 0)

def key_up(self):
    self.pi.write(self.gpio, 0 if self.active_high else 1)

def _sleep_ms(self, ms: int):
    time.sleep(ms / 1000.0)

def send_symbol(self, symbol: str):
    # symbol is '.' or '-'
    self.key_down()
    self._sleep_ms(self._dit_ms if symbol == '.' else self._dah_ms)
    self.key_up()
    # intra-element gap (1 dit)
    self._sleep_ms(self._dit_ms)

def send_letter(self, pattern: str):
    # pattern like ".-." ; between symbols we already leave 1 dit in send_symbol
    for i, s in enumerate(pattern):
        self.send_symbol(s)
    # inter-letter gap is 3 dits total; we already waited 1 dit after last element
    self._sleep_ms(2 * self._dit_ms)

def send_wordgap(self):
    # inter-word gap is 7 dits total; after last letter we already left 3 dits total,
    # so add 4 more dits here to reach 7.
    self._sleep_ms(4 * self._dit_ms)

def close(self):
    self.key_up()
    self.pi.stop()

app.py (Flask web server + endpoints)

// Serves the UI, encodes text to Morse, and keys the rig via GPIO.
from flask import Flask, render_template, request, jsonify
from morse import text_to_morse, dit_ms
from keyer import CWKeyer

CONFIG: pick your GPIO pin connected to optocoupler LED (with series resistor)

GPIO_PIN = 18 # PWM-capable, but here used as digital out
app = Flask(name)

Keep a single keyer instance; adjust WPM per request

_keyer = CWKeyer(GPIO_PIN, wpm=18, active_high=True)
@app.route("/")
def index():
return render_template("index.html")
@app.post("/api/send")
def api_send():
data = request.get_json(force=True)
text = data.get("text", "").strip()
wpm = int(data.get("wpm", 18))
if not text:
return jsonify({"ok": False, "error": "No text"}), 400
_keyer.set_wpm(wpm)
word_list = text_to_morse(text) # list of words → list of letter patterns
try:
for letters in word_list:
for pattern in letters:
_keyer.send_letter(pattern)
_keyer.send_wordgap()
except Exception as e:
return jsonify({"ok": False, "error": str(e)}), 500
return jsonify({"ok": True})
@app.post("/api/wpm")
def api_wpm():
data = request.get_json(force=True)
wpm = int(data.get("wpm", 18))
_keyer.set_wpm(wpm)
return jsonify({"ok": True, "dit_ms": dit_ms(wpm)})
@app.get("/api/health")
def api_health():
return jsonify({"ok": True})

Graceful shutdown (optional)

@app.route("/api/shutdown", methods=["POST"])
def shutdown():
func = request.environ.get("werkzeug.server.shutdown")
if func:
func()
_keyer.close()
return "Shutting down"
if name == "main":
app.run(host="0.0.0.0", port=5000)

templates/index.html (Web UI with buttons and live status)

<!doctype html> <html> <head> <meta charset="utf-8"/> <meta name="viewport" content="width=device-width, initial-scale=1"/> <title>Pi CW Console</title> <link rel="stylesheet" href="/static/styles.css"> </head> <body> <div class="wrap"> <h1>Raspberry Pi CW Console</h1> <div class="

You said:

how much is a transmitter

ChatGPT said:

It depends a lot on what kind of transmitter you want (power, features, bands, kit vs built, commercial vs QRP). Here’s a breakdown + example prices:

Price ranges (rough guide)

Category	Typical Use / Power	Approx Price Range*
QRP / low power, simple CW / kit	1 W, minimal features	$20 – $300
Entry-level transceiver (HF + CW + SSB)	10 W to 100 W, general-purpose	$300 – $1,500
Mid / advanced transceivers	More bands, DSP, higher quality, more robustness	$1,500 – $5,000+
Specialty / contest / commercial / high power	High performance, features, large output	$5,000 – $10,000+

* These are ballpark ranges in the U.S. retail / kit / used market as of 2025.

Example transmitters / transceivers

(These are “transmit-capable” radios, not receive-only RTL-SDRs.)

Icom IC‑7300 100 W HF Transceiver
$1,099.95
•
DX Engineering + others

Yaesu FT‑991A All‑Band Transceiver
$1,299.95
•
DX Engineering + others

MFJ QRP‑Cub 40 m Kit
$119.95
•
mfjenterprises.com + others

Pixie CW 40 m Kit
$14.99
•
Etsy

Rocket Box 500DL CW Transmitter
$529.99
•
CB Radio Supply

Realistic HTX‑100 10 m SSB/CW
$159.80
•
eBay

QRP CW Transmitter 80/40 Kit
$207.00
•
Etsy

usdx+ HF Transceiver
$138.88
•
bruceshark.com
Here are a few highlights:

Icom IC‑7300: Full-featured 100 W HF transceiver. Price is around $1,099.95 in many U.S. listings.
Yaesu FT‑991A: Covers HF + VHF/UHF, all modes including CW, ~100 W. Price ~ $1,299.95.
MFJ QRP‑Cub 40 m Kit: A kit-level low-power CW transceiver for 40 m. Price ~ $242 (kit).
Pixie CW 40 m Kit: Very low-power CW kit (~360 mW output). Price ~ $14.99.
Rocket Box 500DL CW Transmitter: CW-only transmitter. Price ~ $529.99.
Realistic HTX‑100: 10 m SSB/CW transceiver. Price ~ $159.80 used.
QRP CW Transmitter 80/40 Kit: Tube / DIY kit for CW on 80/40 m. Price ~ $207.
usdx+ HF Transceiver: Portable HF with multiple bands. Price ~ $138.88.

What to expect / which to pick

If you just want to experiment with CW, a QRP kit or low-power transmitter is cheap and fun.
If you want a full “ham station”, go with a transceiver like the Icom IC-7300 or Yaesu FT-991A — they include both transmit and receive, band switching, filters, etc.
If buying new, expect a good transceiver to run you $1,000 to $2,000 or more (depending on features).
Used gear is common in ham radio — you can often find older but capable rigs at lower prices.

If you tell me what power level (1 W, 10 W, 100 W, etc) or bands you want (HF, VHF, etc), I can narrow it further and suggest what’s appropriate (and legal). Do you want me to pick one for your Raspberry Pi + CW setup?

Flynn · Oct 1, 2025

Yeah, that’s exactly what most people end up realizing with SDR dongles — they’re more of a toy / hobbyist exploration tool than a serious replacement for comms infrastructure.

You basically get:

A $30–$50 USB dongle (RTL-SDR.com or clones)
A whip antenna or something better if you mount it outside
Free software (SDR#, CubicSDR, GQRX, etc.)

With that, you can:

Scan AM/FM broadcast radio (music, news, talk shows)
Listen to shortwave international stations if your antenna is decent
Pick up air traffic control (AM VHF)
Decode ADS-B from planes (live aircraft tracking)
Monitor NOAA weather radio and satellites
Play with morse code, ham signals, CB, police/fire/EMS (if not encrypted)
Experiment with digital signals (APRS, AIS ship tracking, trunked radio, pager messages)

But — it’s receive-only unless you buy a full transceiver (HackRF, LimeSDR, USRP, etc.), and any transmitting at meaningful power means a ham license.

So yeah — “a toy” is fair, but it’s a fun one because you can open up a whole invisible world just with software + antenna + dongle.

Do you want me to make you a list of the best “useful” things you can realistically do with your dongle + Raspberry Pi 5 so it’s not just a shelf toy?

Flynn · Oct 1, 2025

Perfect — here’s a solid rundown of useful + fun projects you can actually do with your SDR dongle + Raspberry Pi 5 so it doesn’t just sit on a shelf:

1. Local Radio & Spectrum Exploration

FM/AM radio stations – stream live radio via your Pi as a network player.
Shortwave listening – world news, music, or weird numbers stations (if your antenna is strong).
Spectrum analyzer dashboard – Pi renders live waterfall displays of RF signals, like a mini control room.

2. Weather Monitoring

NOAA Weather Radio – constant broadcasts of local forecasts.
Weather satellites (NOAA APT, Meteor M2) – capture images directly from space (your Pi decodes them into actual weather maps).

3. Aircraft Tracking (ADS-B)

ADS-B receiver – track planes in real time (flight numbers, altitude, speed).
Run PiAware or Dump1090 – push your data to FlightRadar24 / FlightAware and get free premium accounts.

4. Ship & Marine Tracking (AIS)

Receive AIS signals from ships on rivers, lakes, or coasts.
Build a live marine radar map on your Pi.

5. Public Safety & Utilities

Listen to fire, EMS, or police dispatch if unencrypted in your area.
Utility companies & railroads – lots of open VHF chatter still around.
Trunked radio decoding – with software like OP25, track digital radio systems.

6. Digital & Ham Radio Fun

Morse code decoder – Pi translates beeps into text.
APRS (ham packet radio) – see location beacons from ham operators.
Radio time signals (WWV/CHU) – atomic clock signals direct from shortwave.

7. Satellites & Space

Satellite beacons – listen to amateur satellites pass overhead.
ISS (International Space Station) – pick up slow-scan TV images when they transmit them.
Inmarsat L-band signals – capture weather text, flight data, or even some rebroadcast news.

8. IoT & Wireless Gadgets

Sniff 433 MHz / 915 MHz devices (garage doors, sensors, remotes).
Capture pager messages (still active in hospitals).
Explore wireless keyboards/mice signals (educational, not hacking).

9. Build a Node Toy

Run your Pi as an RF Dashboard Node — waterfall + buttons in a browser.
Tie it into RabbitMQ or MQTT (like your other projects) so it becomes a real-time “radio ear” in your network.

What you need for most of these:

A decent antenna upgrade (mag-mount VHF/UHF, or a long-wire shortwave).
Pi 5 + RTL-SDR dongle + software (dump1090, rtl_fm, CubicSDR, GQRX, OP25, etc.).
Optional: connect to the internet to feed networks (Flightradar24, APRS, etc.).

Basic Radio Concepts

​