Tired of short-range Meshtastic nodes? Ready to build a serious, long-distance gateway or repeater? Say hello to the PiMesh 1W, the powerful new LoRa HAT for the Raspberry Pi that’s officially live and ready to take your mesh network to the next level!

Developed by MeshSmith, the PiMesh 1W is engineered specifically for enthusiasts who demand maximum range and reliability from their Meshtastic infrastructure.

Key Features That Set PiMesh 1W Apart

The PiMesh 1W is a 1-Watt (30 dBm) LoRa HAT designed to transform your Raspberry Pi into the ultimate Meshtastic node.

• 1-Watt (30 dBm) LoRa Power: Maximize your transmission range! This is the full power allowed for unlicensed use in the ISM band (in the USA, with responsible antenna use).
• Built for Meshtastic: Optimized for long-range Meshtastic gateways, repeaters, and telemetry nodes, leveraging the capabilities of meshtasticd on Linux. It uses the same reliable radio module and pinout as the popular MeshAdv hat for easy configuration (use the lora-MeshAdv preset).
• Integrated GPS & PoE Options: Deploy your node virtually anywhere with optional modules for Power over Ethernet (PoE) and GPS, making remote, high-altitude installations simple and neat (Note: PoE is not supported on the Raspberry Pi 5 due to the connector change).
• Stemma QT/Qwiic Port: Easily add plug-and-play sensors to your node for environmental monitoring, telemetry, or custom projects.
• ** robust SMA Connector:** Unlike fragile IPEX connectors, the PiMesh 1W uses a durable SMA connector for a secure, reliable antenna connection.
• Broad Pi Support: Supports Raspberry Pi 3, 4, 5, and Zero models.

Why Choose the PiMesh 1W?

While there are other options, the PiMesh 1W is a purpose-built solution that addresses critical needs for serious Meshtastic users:

• Superior Range: The 1W output ensures your gateway hears and is heard across vast distances.
• Reliable Performance: It includes a TXCO (Temperature-Compensated Crystal Oscillator), which is crucial for maintaining stable signal frequency—a known weakness of some other HATs that lack this feature.
• All-in-One Deployment: With integrated GPS and optional PoE, you can mount your node atop a tall mast and run a single Ethernet cable for both power and data.

Support the Work, Build Your Network

The PiMesh 1W is more than just a product; it’s a starter project by MeshSmith designed to fund more advanced open-source LoRa hardware—including multi-radio boards and bigger ideas currently in the prototyping phase.

If you’re ready to upgrade your Meshtastic infrastructure or support the development of innovative new LoRa devices, grab your PiMesh 1W today!

Official Link: https://meshsmith.net/

The post Introducing the PiMesh 1W: Power Up Your Meshtastic Network appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re an amateur radio operator dabbling with APRS (Automatic Packet Reporting System), you’ve probably heard of software like Xastir or APRSISCE. But there’s another powerful, under-the-radar option out there: YAAC, short for Yet Another APRS Client.

Developed by Andrew Pavlin, KA2DDO, YAAC is a cross-platform APRS client written in Java. It’s free, open-source, and remarkably feature-rich. Whether you’re trying to track APRS packets from the Internet or your TNC, set up an I-Gate, or experiment with plugins and telemetry — YAAC can handle it all.

Why YAAC?

YAAC isn’t just another APRS visualizer. It’s a full-fledged APRS client that runs on Windows, Linux, macOS, Raspberry Pi, and even FreeBSD. The UI is simple but functional, and there’s extensive documentation to help you get started. What really sets YAAC apart is its modular design and extensibility. You can write plugins or use existing ones to integrate features like:

• Weather overlays
• Aircraft tracking via ADS-B
• Callsign database lookup
• Secure authentication over APRS
• AREDN mesh object mapping
• Repeater finder
• Integration with TAK networks (yes, you can bridge data to ATAK/iTAK!)

Key Features

• Multiple map views using OpenStreetMap, with offline support
• Operates as a standalone client, digipeater, or Internet gateway
• Connects via TNCs (Kenwood, TinyTrak, Mobilinkd, etc.) or soundmodems (DireWolf, UZ7HO)
• Full support for APRS-IS, including secure SSL-based login (experimental)
• GPS and weather station integration
• Can be automated, extended, and used headless for lightweight setups

Runs Anywhere – Even on Raspberry Pi

YAAC is a solid option for low-power or portable use. It works well on Raspberry Pi models 2, 3, and 4, and has specific guidance for installation on Pi OS. If you’re setting up a field APRS tracker or a compact I-Gate node, this is worth a look.

Installation is as simple as downloading the .zip, unzipping it, and launching with:

java -jar YAAC.jar

Just make sure you’re running Java 8 or later with GUI (not headless-only).

Plugin Ecosystem

YAAC includes a surprisingly rich plugin environment. Some of the coolest plugins I found:

• takplugin: allows YAAC to interface with ATAK/iTAK – useful for tactical teams or SAR
• soundsplugin: enables event-triggered speech alerts
• telemetryalarmplugin: monitor APRS telemetry and trigger warnings
• dynamicobjectsplugin: create moving APRS objects based on GPX tracks

You can install them directly from the app under Help → Install Plugins.

What’s the Catch?

YAAC is written in Java, and while it works well, the interface is a bit old-school compared to modern UI expectations. It also doesn’t run on Android (yet), since it relies on AWT and Swing for its graphics. But if you’re comfortable with a traditional desktop-style interface, you’ll find it reliable and flexible.

It might take some initial setup — especially for configuring TNCs or APRS-IS connections — but once it’s running, it’s rock solid.

Final Thoughts

YAAC is one of those hidden gems in the ham radio software world. It’s open, active, and made with care by someone who clearly understands the needs of operators. Whether you’re just listening to APRS traffic or building a more complex setup (digipeater, I-Gate, or telemetry station), YAAC is up to the task.

Give it a try. Unzip it, configure your port, and get on the air.
And if you’re a developer, jump in and write a plugin — the community could use more contributors.

Download YAAC here

The post Exploring YAAC: A Powerful Open-Source APRS Tool for Hams appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re into amateur radio and love to tinker, here’s something weirdly fun to experiment with: rpitx2 — a software-only RF transmitter for the Raspberry Pi.

No, it’s not a substitute for your HF rig. No, it’s not going to replace your IC-7300 or even your Baofeng. But if you’re looking for an experimental project that lets you transmit real RF signals using just a Raspberry Pi and a bit of wire, rpitx2 is surprisingly powerful — in a nerdy kind of way.

What Is rpitx2?

rpitx2 is the second generation of the original rpitx by F5OEO. It’s a general-purpose RF transmitter that works by abusing (intentionally!) the Raspberry Pi’s GPIO pin to generate radio signals between 5 kHz and 1500 MHz. That covers everything from VLF to UHF.

All you need is:

• A Raspberry Pi (several models supported, more on that below)
• A short wire connected to GPIO 4 (pin 7) as an antenna
• The rpitx2 software
• And a sense of curiosity, because this is very much a let’s-see-if-it-works kind of project

A Word of Warning

This is experimental software. It hasn’t been certified for compliance with RF transmission regulations. You are entirely responsible for how you use it. If you’re a licensed amateur operator, stay within legal bands and power limits. If you’re not licensed — don’t transmit at all. Just use it into a dummy load or observe via SDR.

Also, don’t expect miracles. This is not a high-quality transmitter. The Pi is doing all the work in software. There’s no filtering, no PA stage, no real impedance matching — just raw RF squeezed out of a pin that was never meant to do this.

It’s great for short-range testing and learning about modulation, not for talking to DXCC entities.

What Can You Actually Transmit?

rpitx2 comes with a bunch of built-in demos and modes:

• FM with RDS: Yes, you can set up a mini pirate radio station (don’t, unless legal) that sends out stereo FM with station text.
• SSB Voice: Transmit your voice using single-sideband — just keep it low power.
• SSTV (Slow Scan TV): Send an image over HF using Martin1 mode and receive it on QSSTV.
• FreeDV: Try your hand at digital voice communication over RF.
• Pocsag: Yep, you can simulate a pager transmission.
• Carrier, Chirp, Spectrum tests: Great for SDR visualization and modulation experiments.

There’s also a “replay” function — you can record a signal with an SDR and replay it via rpitx2, for fun or analysis.

Hardware Compatibility

Here’s a quick breakdown of which Pi models work:

Raspberry Pi	Status
Pi Zero	Works
Pi Zero W	Works
Pi 3B / 3B+	Works
Pi 4	Sometimes
Pi 400	Sometimes
Pi 5	Not yet

Some models, especially Pi 4 and 400, can be unstable. Pi 3A+ seems to work quite well. Also, remember: no filtering means your Pi is potentially throwing out a lot of unwanted signals (harmonics). Be a good neighbor. Use a low-pass filter, or better yet, a dummy load.

Range? Power? Don’t Expect Much

At best, the Pi can output around 50 mW, depending on the GPIO drive strength and settings. The signal is enough to get picked up across a room or even down the block with the right antenna — but it’s not going to break through noise floors or reach satellites.

It’s been reported that a ~79 cm wire can give you a few hundred meters of range on 95 MHz in ideal conditions, but that’s highly variable.

The real value here isn’t range or power — it’s the education. You’ll learn about modulation schemes, SDR waterfall displays, antenna resonance, and more, all for the cost of a Raspberry Pi and some wire.

Use Cases for Hams

So why would a licensed ham care about this?

• Modulation experiments: Visualize FM, AM, SSB, and digital modes.
• Test signal generation: Useful for SDR calibration or receiver alignment.
• Digital mode experiments: Try encoding and decoding FreeDV, SSTV, POCSAG, etc.
• Beacons: Set up a temporary WSPR/OPERA-style beacon on ISM bands.
• Educational demos: Perfect for club meetings, STEM events, or just showing friends how modulation works.

Final Thoughts

rpitx2 is not a serious transmitter — but it’s not supposed to be. Think of it more like a radio playground for hackers and hobbyists. You’ll learn a lot, break a few things, maybe even disturb your FM radio a little. Just be responsible and legal about it.

It’s a brilliant reminder that sometimes, the best tools for learning aren’t the most expensive — they’re the most hackable.

Visit and learn more at https://github.com/KubaPro010/rpitx2

The post Playing with RF: rpitx2 Turns Your Raspberry Pi into a Radio Transmitter appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In a world flooded with streaming apps and online radios, sometimes you just want the real thing — good old FM radio that doesn’t drain your data or rely on Wi-Fi. That’s where RFM Radio comes in! This awesome app taps directly into your phone’s hardware FM chip , letting you listen to local stations anytime, anywhere — even without an internet connection.

What is RFM Radio?

Developed by Vladislav Veluga, RFM Radio is an open-source (GPL-3.0 licensed) app designed for Android phones with Qualcomm Snapdragon processors. It’s not your typical internet streaming app — it actually uses your phone’s built-in FM tuner to pick up real radio waves. That means crystal-clear local radio right on your device, no buffering, no data fees!

Key Features That Rock:

• Real FM Tuning: Uses your phone’s Qualcomm Snapdragon FM chip to listen to real broadcast radio.
• RDS Support: Displays station info like Program Service (PS) names and Radio Text (RT) so you always know what’s playing.
• Signal Strength Meter: Shows signal strength in decibels (dB) — find the best spots for clear reception.
• Record Your Shows: Save your favorite broadcasts as .wav or .mp3 files to replay later.
• Favorites Lists: Organize your top stations into multiple lists for easy access.
• Auto Station Search: Scan the airwaves to discover all available stations nearby.
• Root Access Required: To work its magic, the app needs root access on your phone.

Which Phones Work?

Only smartphones with Qualcomm Snapdragon processors are supported — but not all models. Snapdragon 632 and 820+ are excluded due to hardware driver issues. Check the official repo for the latest supported devices!

Why Use RFM Radio?

• No Internet Required: Perfect for travel, remote areas, or if you just want to save data.
• Emergency Ready: Stay tuned to local news and emergency alerts without network dependency.
• Battery Friendly: FM radio uses way less power than streaming apps — longer listening sessions guaranteed!
• Privacy First: No internet means no tracking or data leaks.
• Open Source: Community-driven and transparent — you can even check the code yourself!

How to Get It?

Download from GitHub or better yet, use an F-Droid client to keep the app updated effortlessly. Clients like Neo Store, Droid-ify, or IzzyOnDroid have the repo enabled by default. Manual repo adding is possible for official F-Droid users.

Final Thoughts

If you love the charm of traditional FM radio and want it on your Android device without the hassle of internet dependency, RFM Radio is a must-have! Root your phone, grab this app, and tune in to your favorite stations anytime, anywhere. The perfect companion for your daily commute, emergency kit, or just chilling at home.

The post RFM Radio: The Real FM Radio App for Android (No Internet Needed!) appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Imagine operating your entire ham radio station remotely — from anywhere in the world — using only a web browser and a Raspberry Pi. Sounds futuristic? Not anymore.

Introducing Simple Ham Radio Remote (SimpleHRR) — a lightweight, browser-based web app designed for amateur radio operators who want to remote control their transceivers over the Internet. Whether you’re using a PC, laptop, Android phone, or iPhone (Safari tested), SimpleHRR brings your station to your fingertips — no extra software, no complex wiring, no subscription fees.

What Is SimpleHRR?

SimpleHRR (Simple Ham Radio Remote) is a web-based remote control system hosted on a low-cost Raspberry Pi (or Le Potato) that connects directly to your amateur radio transceiver via USB and your home network via Ethernet.

No SCU-LAN10.
No Remote Desktop.
No TeamViewer.
Just a browser — that’s it.

Key Features

• Full Radio Control: Power, Band, Mode, VFO, TX/RX settings, filters, notch, gain — everything is right there.
• Two-Way Audio: Talk and listen directly from the browser — no need for Mumble, Skype, or other VOIP software.
• Integrated Webcam Feed: Keep an eye on your shack or monitor your equipment remotely.
• Web Server Included: Host your own station schedule or control page.
• Multi-User Support: Set up individual accounts for club members or shared stations.
• Browser-Based UI: Fully functional interface using mouse wheel and keyboard shortcuts (e.g., spacebar for PTT).
• Smart Fail-Safe: Automatically turns off radio if the connection drops — no risk of accidental transmissions.

Radios Supported

Currently tested with:

Icom: IC-7300, IC-7610, IC-705 (HF/VHF/UHF), IC-2730A
Yaesu: FT-710, FT-2000, FT-950, FT-450

Thanks to its use of CI-V and CAT protocols, many other radios may also work out of the box.

Why SimpleHRR?

• No Subscription Fees – It’s free and open for all hams.
• Headless Setup – No monitor or keyboard required. Just flash the prebuilt image to a microSD card and go.
• Runs on Raspberry Pi or Le Potato – Inexpensive, low-power devices make the setup super affordable.
• LAN + WiFi + Internet – Connect locally or remotely. Even works with mobile WiFi hotspots.

Setup Requirements

• Raspberry Pi 4 (or similar SBC)
• Raspbian Lite (preloaded image provided)
• USB cable for your radio
• 8GB or larger microSD card
• 5V power supply
• Network connection (LAN/WiFi)

Use your favorite microSD flashing tool, boot up the Pi, and access your remote shack via browser login — it’s that easy.

Works With:

• Google Chrome
• Mozilla Firefox
• Safari (tested on iPhone 12)
• Any modern web browser

Use Case Example: Remote Control the Icom IC-7300

With just a Raspberry Pi 4 and a USB cable, you can remotely:

• Power on/off your IC-7300
• Select bands and modes
• Use VFO tuning and filters
• Transmit and receive with integrated audio
• Monitor your shack with a webcam

All through a clean, intuitive web interface.

Final Thoughts

If you’re looking for a truly simple, reliable, and cost-effective way to control your amateur radio station from anywhere, Simple Ham Radio Remote might just be the tool you’ve been searching for.

No frills. No bloat. Just your radio, your Raspberry Pi, and your browser.

Get started today at SimpleHRR.com and transform how you connect to the airwaves — remotely, efficiently, and with total control.

The post SimpleHRR: The Easiest Way to Remote Control Your Ham Radio Station with Just a Raspberry Pi appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’ve ever wanted to explore the radio spectrum from anywhere in the world, OpenWebRX+ offers a modern and accessible way to do just that — right from your web browser.

Built on top of the original OpenWebRX project, OpenWebRX+ is a community-driven fork that adds powerful features and support for a broader range of use cases, including amateur radio, shortwave listening, digital mode decoding, and even aviation or maritime monitoring.

What is OpenWebRX+?

OpenWebRX+ is a web-based software-defined radio (SDR) receiver platform. It lets multiple users access and listen to live SDR streams through a simple, responsive web interface. No complicated setup is needed for the listener — just open your browser and tune in.

Whether you’re a licensed ham radio operator, a shortwave enthusiast, or just curious about what’s on the airwaves, OpenWebRX+ makes radio accessible and enjoyable.

Key Features

• Multi-user support with efficient bandwidth sharing
• Real-time waterfall display with fast refresh and zoom
• AM, FM, SSB, CW, and digital modes (e.g., FT8, DMR, D-STAR, POCSAG)
• TETRA decoder
• Automatic decoder modules for popular digital signals
• Web-based configuration interface
• Mobile-friendly design

Thanks to its modular architecture, OpenWebRX+ continues to grow and integrate new features that help hobbyists, educators, and researchers monitor and explore radio signals more effectively.

Great for:

• Amateur radio operators who want to set up a remote receiver
• Radio clubs looking to make their SDR available to the public
• Developers and researchers working with digital radio protocols
• Listeners who enjoy discovering international broadcasts or local emergency services (where legal)

Easy to Set Up

You can run OpenWebRX+ on various hardware, including:

• Raspberry Pi (for light to moderate use)
• Intel/AMD Linux servers
• SDRs like RTL-SDR, Airspy, HackRF, LimeSDR, and others

The project is open-source and available on GitHub at:
https://github.com/luarvique/openwebrx

Full installation instructions, support, and community discussions are actively maintained.

Join the Global Listening Network

There’s something magical about tuning into signals from halfway across the world. Whether you’re decoding digital messages, monitoring weather balloons, or just enjoying the hiss of static, OpenWebRX+ connects you to the heartbeat of the RF spectrum.

It’s time to put your SDR to good use.

The post Explore the Radio Spectrum with OpenWebRX+ appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

It’s organized by Michael KC8OWL, and the idea is simple: just send a short APRS message to ANSRVR or APRSPH sometime on Thursday (UTC).

That’s it. But like many of us, I sometimes forget to send mine. So I decided to build a little automation to take care of it.

Why I Built This

I wanted something that would:

• Automatically send my check-in message every Thursday
• Run quietly in the background
• Work on my Raspberry Pi server
• It is easy to manage with Docker

And that’s how the 9M2PJU APRS Thursday Check-in Bot was born.

What It Does

This bot runs 24/7 and sends the following APRS message every Thursday at 9:00 PM Malaysia Time (MYT):

HOTG Hello from CALLSIGN

It connects to aprs.hamradio.my:14580 using aprslib and sends the message exactly the way the #APRSThursday net expects.

You Can Also Test It Anytime

I also added a test mode. Just run:

docker compose run --rm aprs-thursday-check-in python /app/aprs-thursday-check-in.py --test

..and it sends the message instantly. Useful for checking if your server or internet connection is working properly.

Tech Stuff

• Written in Python
• Dockerized with a super lightweight python:alpine image
• Runs well on low-resource devices

You just clone the repo, build it with Docker, and let it run. No need to set up cron or anything.

Want to Use It?

Here’s the GitHub repo:
https://github.com/9M2PJU/9M2PJU-APRS-Thursday-Check-in-Bot

Setup is simple. Just:

git clone https://github.com/9M2PJU/9M2PJU-APRS-Thursday-Check-In-Bot.git
cd 9M2PJU-APRS-Thursday-Check-In-Bot
docker compose up -d --build

That’s it. The bot will now check in every Thursday on its own.

Final Thoughts

I built this for myself, but I figured it might help someone else, too. If you want to support the APRS community and keep message-based activity alive, this is an easy way to do it.

Feel free to fork, improve, or just use it as-is. I’ll keep updating it if I come up with new ideas.

The post 9M2PJU APRS Thursday Check-in Bot appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In today’s increasingly connected amateur radio landscape, digital linking is no longer a novelty—it’s a vital part of modern ham operations. The SHARI PiZero (SA818 Ham Allstar Radio Interface for PiZero) is a purpose-built solution designed for hams who want a compact, efficient, and reliable Allstar node that they can build themselves. Whether you’re an experienced builder or new to DIY radio kits, the SHARI PiZero offers an excellent balance of performance, flexibility, and value.

What is SHARI PiZero?

The SHARI PiZero is a custom-designed hardware kit that transforms a Raspberry Pi Zero 2W into a fully functioning Allstar Node. Designed for use in the amateur radio service, the kit incorporates a NiceRF SA818 embedded radio module, available in UHF (420–450 MHz) or VHF (144–148 MHz) versions. It provides 250–500 milliwatts of RF power—ideal for hotspot use or local repeater access.

The kit includes a dedicated USB audio interface (CM108B), a lowpass filter to meet FCC Part 97 spurious emissions requirements, and a three-port microUSB hub to support accessories like USB-to-Ethernet adapters or external keyboards. This makes setup and configuration via wired Ethernet not only possible but preferred, especially for first-time builders working with the HamVOIP Allstar image.

Key Features at a Glance

• Embedded NiceRF SA818S module in UHF or VHF band options
• CM108B USB audio chip for high-quality audio handling
• Lowpass LTCC filter to ensure spectral cleanliness
• Integrated 3-port USB hub for peripherals and Ethernet adapters
• Surface mount components pre-installed — minimal soldering required
• Compact and rugged Hammond aluminum enclosure
• Optional pre-soldering and full assembly services

Construction and Setup: Designed with Builders in Mind

SHARI PiZero is designed as a partially pre-assembled kit. The PCB arrives with all small surface-mount components factory-installed. As the builder, you’ll install only a few through-hole components: the SA818 radio module, SMA RF connector, and headers for the Raspberry Pi. All necessary cables are included, and detailed instructions are provided via request.

One of the advantages of the SHARI PiZero design is its thoughtful inclusion of hardware for a clean build—such as 3D-printed end caps and optional blank end plates for custom modifications.

The Raspberry Pi Zero 2W (not included in the base kit) plugs directly into the SHARI motherboard using the GPIO header and a custom USB cable. Since the PiZero doesn’t have an Ethernet port, the onboard USB hub lets you plug in a microUSB-to-Ethernet adapter, ensuring a stable connection for image configuration and updates.

Kit or Fully Assembled: Your Choice

SHARI PiZero is available in two models:

• PiZeroU (UHF 420–450 MHz)
• PiZeroV (VHF 144–148 MHz)

You can purchase the kit for just $100, which includes all components except the Raspberry Pi Zero 2W, power supply, and microSD card. If you prefer, for an additional $5, the SA818 module can be pre-soldered for you.

Don’t have the time or tools to assemble the kit yourself? A fully assembled and tested SHARI PiZero is available for $205, which includes the Raspberry Pi Zero 2W and a power supply. For wired networking, an optional microUSB-to-Ethernet adapter can be added for $10—tested and guaranteed to work with the HamVOIP Allstar distribution.

Shipping to U.S. addresses is a flat $9 via USPS Priority Mail.

Community and Support

Builders and users of SHARI can access community-based support through the SHARI Groups.io group, which serves as the primary hub for troubleshooting, build questions, and ideas. For software-related support (e.g., configuring HamVOIP or ASL), users are encouraged to consult the respective project sites.

Get Started

Whether you’re setting up a remote Allstar node at your vacation cabin, building an RF link for your club repeater, or just want a portable digital access point, SHARI PiZero is a reliable and customizable solution.

To order, download the SHARI PiZero Order Form and email it to kits4hams@gmail.com. You’ll be added to the waitlist and notified when your kit is ready. Payment is accepted via PayPal.

Visit https://kits4hams.com/shari-pizero

The post Build Your Own Compact Allstar Node with SHARI PiZero appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

What Is ACARS Hub?

ACARS Hub is a Docker container designed to collect, parse, and visualize messages from a variety of aircraft communication systems. If you’ve ever used acarsdec, dumpvdl2, or dumphfdl, you’ll know that raw output can be technical and terse. ACARS Hub improves on this by enriching the decoded messages with data from the amazing team at Airframes.io, making messages easier to read and interpret.

It works across architectures—amd64, arm64, armv7, armv6, and even 386—making it perfect for devices like the Raspberry Pi.

What You’ll Need

To get started, you’ll need:

• A Linux system that can run Docker (a Raspberry Pi works great)
• One or more RTL-SDR dongles (at least one for ACARS, ideally a second for VDLM2)
• Docker and Docker Compose
• One or more SDR decoders (see below)

Decoding support includes:

• acarsdec (recommended: airframes fork)
• dumpvdl2 (preferred VDLM2 decoder)
• vdlm2dec
• dumphfdl
• satdump for Inmarsat
• gr-iridium toolkit for Iridium
• JAERO for L-band satellite decoding

All these decoders can run externally and push decoded JSON to ACARS Hub over UDP.

Ports and Connectivity

Here are the main ports you’ll deal with:

Using these, you can stream messages into the container and even pipe data out to other systems for further analysis or visualization.

Docker-Compose: The Fast Track Setup

Here’s a minimal working setup for your docker-compose.yaml:

services:
  acarshub:
    image: sdrenthusiasts/acarshub:latest
    ports:
      - 80:80
      - 5550:5550/udp
      - 5555:5555/udp
      - 5556:5556/udp
      - 5557:5557/udp
      - 5558:5558/udp
      - 15550:15550
      - 15555:15555
      - 15556:15556
      - 15557:15557
      - 15558:15558
    volumes:
      - acarshub_data:/run/acars
    environment:
      - ENABLE_WEB=true
      - ENABLE_ACARS=external
      - ENABLE_VDLM=external
      - DB_SAVEALL=false
volumes:
  acarshub_data:

This setup enables ACARS and VDLM2 processing, exposes the necessary ports, and stores data on a local volume.

Performance Tips

Running a database on something lightweight like a Raspberry Pi? You’ll want to:

• Mount /run/acars/ as a tmpfs to reduce SD card writes
• Set DB_SAVEALL=false to avoid storing uninformative messages
• Limit data retention by adjusting DB_SAVE_DAYS

Want better search speed? Temporarily enable AUTO_VACUUM=true to clean the database.

Enhancing Your Map with ADS-B Data

To display ADS-B targets on the ACARS Hub map:

1. Run tar1090 and readsb on the same host
2. Enable ADS-B in ACARS Hub with: - ENABLE_ADSB=true - ADSB_URL=http://tar1090/data/aircraft.json
3. Set your lat/lon for correct range rings

You’ll be able to click aircraft on the map and see related messages.

Make the Data Accurate for Your Region

Airline codes can be tricky. If you notice callsigns mapping incorrectly (e.g. UPS showing up as BahamasAir), you can fix them locally using the IATA_OVERRIDE environment variable. Example:

IATA_OVERRIDE=UP|UPS|United Parcel Service;US|AAL|American Airlines

Web Interface & Tricks

ACARS Hub has a responsive web UI on port 80. You can:

• Press p on the Live Messages page to pause auto-scroll
• Use the search page to filter messages by keyword or callsign
• Connect other tools or visualizers to exposed JSON ports like 15555 (VDLM2) or 15550 (ACARS)

Future Developments

The project’s active and rapidly evolving. Upcoming features include:

• A revamped UI
• Desktop apps
• Improved message matching between ACARS and ADS-B

Get Help or Contribute

ACARS Hub is open-source and community-driven. You can:

• Raise issues or contribute code on GitHub
• Join the Discord server for support and ideas

Whether you’re a seasoned SDR hobbyist or new to decoding, ACARS Hub makes it easier than ever to monitor real-world aircraft communication with real-time visualization and analysis.

Visit https://github.com/sdr-enthusiasts/docker-acarshub

The post A Look into ACARS Hub and How to Set It Up on Your SDR System appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Logging QSOs shouldn’t feel like work — especially when you’re running portable. Whether you’re activating a POTA park, chasing summits for SOTA, joining Field Day, or just working HF from a hilltop, you need a logging app that’s fast, offline-ready, and built for real operators.

HAMRS is exactly that.

It’s built from the ground up for modern ham radio ops — simple UI, solid performance, and zero learning curve. Whether you run 100 watts or QRP, HAMRS gives you a clean, fast way to log contacts in the field, then export them for LoTW, QRZ, or your main shack log.

Why HAMRS Matters for Portable Ham Radio

• Offline logging with fast entry — no internet needed
• Templates for POTA, SOTA, Field Day, etc.
• Auto-fill grid squares, park info, and more
• ADIF import/export — seamless integration with Logbook of The World, QRZ, etc.
• FLRig support — auto-fill frequency/mode from your rig (Pro)
• Dark mode for visibility in all lighting conditions
• Built for speed — logs pileups without freezing or lagging

If you’re logging by hand or using bloated shack software on your laptop, HAMRS will feel like a breath of fresh air.

Install HAMRS on Arch Linux (and Derivatives)

On Arch, Manjaro, CachyOS, or any Arch-based distro, install it from the AUR with:

yay -S hamrs-appimage

This installs the latest AppImage version and sets up a launcher in your menu. Launch it, select your logging template, and you’re ready to go.

Perfect for:

• QRP operators
• HF/VHF/UHF field deployments
• Satellite logging (custom templates supported)
• EMCOMM / field exercises
• Club stations
• Quick home station logging without extra config

Exporting and Uploading Logs

Once you’re done operating, you can:

• Export logs in ADIF format
• Upload directly to QRZ (built-in feature)
• Import into TQSL for Logbook of The World
• Share logs with your club or contest team

HAMRS speaks the language of ham radio. No conversions, no weird formats.

Support the Developer

HAMRS is built by a fellow ham with optional Pro features like rig control and cloud sync.

Support the project via:

• Patreon
• Merch
• Direct donation

Final Key Point

You already care about radios, antennas, propagation, and signal reports — don’t let your logging app be the weakest part of your setup.

HAMRS was made for you — the operator in the field, in the car, in the club tent. If you value efficiency and simplicity while still hitting all the right ham features, this is your logger.

Every Day Is Field Day
https://www.hamrs.app

The post A Better Logger for Hams: HAMRS appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Enter the NAS — Network Attached Storage — a powerful and often overlooked tool for modern amateur radio operators. Whether you’re a casual hobbyist or a serious station manager, a NAS can simplify and secure your digital life in the shack.

Let’s explore how NAS systems can benefit amateur radio operators, practical use cases, and some guidance to help you set one up.

What is a NAS?

A NAS is a dedicated device or server connected to your local network that stores data and provides services like file sharing, media streaming, backups, and more. Think of it as your personal cloud, available on your LAN (and remotely if you allow it).

Open-source NAS systems like TrueNAS, OpenMediaVault, Rockstor, and XigmaNAS make it easy and affordable for hams to build one using spare hardware or a Raspberry Pi.

Why Hams Should Consider a NAS

Here are several ways a NAS can become a central part of your shack:

1. Logbook and Data Backup

Store all your digital logbooks (e.g., N1MM, CQRLOG, Ham Radio Deluxe, Fldigi) in one place and access them from multiple devices.

• Automatically back up logs from your Raspberry Pi or Windows machine.
• Share your logbook with your contesting team on the same LAN.
• Keep a version history in case of accidental deletion.

2. SDR Recordings & Waterfalls Archive

Running SDR receivers like SDRplay, HackRF, or RTL-SDR? Those I/Q recordings and spectrogram images can take up a lot of space. A NAS lets you:

• Store massive SDR data files securely.
• Host them for playback or offline analysis.
• Use ZFS/Btrfs snapshots to prevent data corruption.

3. Web Server for Shack Tools

Host useful ham tools like:

• Local callsign lookup database
• DX cluster web interface
• OpenWebRX or KiwiSDR server
• Static wiki/documentation for station SOPs

A NAS with Docker support can run these tools as services—without tying up your main shack PC.

4. Shared Resources and Scripts

Many hams use scripting (Bash, Python, Node-RED) for automating things like antenna switching, remote rig control, or APRS messaging. Store all your scripts and station configs in one place.

Bonus:

• Sync with Git for version control.
• Share with your team during field day or emergency comms ops.

5. APRS and Meshtastic Gateway Backups

Running APRS I-Gates, Meshtastic bridges, or Direwolf/KISS TNC setups? Store:

• Config files (JSON, ini, conf)
• Logs of packet traffic
• Diagnostic captures (tcpdump, AX.25 monitoring)

Keep everything ready for instant restore if your SBC or microSD card fails.

6. SSTV and Digital Mode Archiving

Store and organize:

• SSTV images
• JS8Call messages
• FT8/FT4 decoded logs
• Signal reports and waterfall screenshots

Add tags or naming conventions for contests, satellite passes, or unusual propagation events.

7. Emergency Communications (EmComm)

Prepare for EmComm deployments by:

• Preloading maps, ICS forms, and software installers.
• Hosting offline resources (e.g., Wikipedia snapshot, repeater directory).
• Synchronizing field logs to your home NAS when the network comes online.

Choosing the Right NAS Setup

Pro tip: Use a UPS (Uninterruptible Power Supply) with your NAS to avoid data corruption during power outages—especially during storms or field deployments.

Real-World Ham Use: Example Scenario

Imagine this:

• You’re operating remote HF from your home, using a Raspberry Pi to control a rig via Hamlib.
• The Pi is running WSJT-X for FT8.
• Logs are automatically pushed to your NAS.
• You’ve configured your NAS to back up these logs to a cloud provider weekly.
• You also run Node-RED dashboards on the NAS to monitor temperature, power, and SWR sensors remotely.

This setup gives you flexibility, reliability, and peace of mind—all using open-source tools and amateur radio creativity.

Getting Started

1. Reuse an old PC or get a Raspberry Pi 4 with a USB drive.
2. Choose your NAS OS (TrueNAS, OpenMediaVault, etc.).
3. Connect it to your local network via Ethernet.
4. Enable services like SMB/NFS, Docker, and snapshots.
5. Start saving, sharing, and serving your ham shack data like a pro.

Final Thoughts

In 2025, the amateur radio shack is no longer just radios and antennas—it’s also data, software, and services. By adding a NAS to your setup, you gain control, resilience, and smarter station management.

Whether you’re a contester, experimenter, satellite operator, or EmComm volunteer, a NAS is an investment that pays off in convenience, security, and scalability.

Stay curious, stay connected, and happy experimenting!

The post How Amateur Radio Operators Can Use a NAS in the Shack: A Practical Guide appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In this post, we’ll explore the top 5 open-source NAS operating systems you can deploy today. Each one is suited to different needs—ranging from powerful enterprise-level setups to simple plug-and-play solutions for beginners.

1. TrueNAS CORE (formerly FreeNAS) – The ZFS King

Base OS: FreeBSD
Filesystem: ZFS
Best for: Power users, enterprises, and anyone who values data integrity

Why TrueNAS CORE?

TrueNAS CORE is the gold standard in open-source NAS software. Built on FreeBSD and leveraging the incredibly robust ZFS file system, it offers data protection features like checksumming, copy-on-write, and built-in snapshots.

It comes with a polished web UI, plugin support (e.g., Nextcloud, Plex, Transmission), replication tools, encryption, and advanced networking. It even supports virtual machines and Docker via its Linux counterpart, TrueNAS SCALE.

Recommended if you have 8GB+ RAM, preferably ECC, and want bulletproof storage with enterprise-level features.

https://www.truenas.com/truenas-core/

2. OpenMediaVault (OMV) – Best for Simplicity and Home Use

Base OS: Debian Linux
Filesystem: ext4, XFS, Btrfs, ZFS (via plugin)
Best for: Home servers, Raspberry Pi NAS builds, beginners

Why OpenMediaVault?

If you’re looking for something lightweight and easy to manage, OMV is your go-to. It’s perfect for home users or beginners wanting to set up a file server, media server, or even a Time Machine backup destination.

With Docker and Portainer integration, you can run containers effortlessly. It also has a large ecosystem of plugins and excellent community support.

Ideal for Raspberry Pi, mini PCs, or old laptops converted into a NAS.

https://www.openmediavault.org/

3. Rockstor – Linux-Based NAS with Btrfs Power

Base OS: openSUSE (newer versions)
Filesystem: Btrfs
Best for: Developers, Docker fans, modern Linux users

Why Rockstor?

Rockstor is a lesser-known but powerful NAS option that revolves around Btrfs, a modern copy-on-write file system with snapshot and compression capabilities. It features a clean web UI, Docker support, and great storage management features.

If you’re into Linux and want an alternative to ZFS, Rockstor’s Btrfs-first approach is worth trying.

Perfect for DIYers and devs looking to experiment with containers and Btrfs.

https://rockstor.com/

4. XigmaNAS (formerly NAS4Free) – Lightweight BSD NAS

Base OS: FreeBSD
Filesystem: ZFS, UFS
Best for: Legacy hardware, users who want a BSD NAS without bloat

Why XigmaNAS?

Think of XigmaNAS as the simpler cousin of TrueNAS. It’s BSD-based, supports ZFS, and runs well on older hardware. The UI is not as polished, but it gets the job done.

It supports all major sharing protocols (SMB, NFS, AFP, FTP, etc.) and can be configured for RAID, iSCSI, and rsync easily.

Great for repurposing older PCs into reliable NAS boxes.

https://www.xigmanas.com/

5. EasyNAS – Minimalist and Straightforward

Base OS: openSUSE
Filesystem: Btrfs
Best for: Total beginners, plug-and-play NAS setups

Why EasyNAS?

True to its name, EasyNAS is built for simplicity. It’s lightweight, quick to install, and has a minimal interface that lets you set up your file server in minutes. It lacks advanced features, but for basic use—like backing up files or sharing over the network—it’s more than capable.

Best if you want a “set it and forget it” NAS with minimal learning curve.

https://easynas.org/

Comparison at a Glance

Final Thoughts: Which NAS Should You Choose?

• Choose TrueNAS CORE if you want maximum reliability with ZFS, advanced features, and don’t mind the extra learning curve.
• Choose OpenMediaVault for ease of use, Raspberry Pi support, and excellent Docker integration.
• Choose Rockstor if you prefer Linux and want to explore Btrfs with Docker.
• Choose XigmaNAS for a light BSD-based NAS on old or underpowered hardware.
• Choose EasyNAS if you want a quick and easy local file server without the fluff.

Have questions or need help choosing the right NAS for your setup? Feel free to reach out or drop a comment below. Whether you’re running this on a recycled PC or a Raspberry Pi, there’s never been a better time to go open-source with your storage.

The post The Best Open Source NAS Operating Systems appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Winlink is an essential tool in emergency and portable amateur radio communications. It allows you to send and receive emails over RF using various modes like VHF, UHF, and HF. In this guide, I’ll walk you through setting up a Winlink client on a Raspberry Pi, turning your Pi into a lightweight and powerful messaging hub.

Whether you’re preparing for EmComm scenarios or operating in remote areas, this setup gives you email access without the internet.

What You’ll Need

• Raspberry Pi 3, 4, or Zero 2 W (running Raspberry Pi OS or Debian-based Linux)
• Internet access for installation
• Your amateur radio license
• A soundcard interface (e.g., Signalink, Digirig, or USB soundcard)
• A transceiver (VHF/UHF or HF)
• A Winlink account (free to register on first connect)

Optional but useful:

• USB GPS (for mobile use)
• Touchscreen or headless SSH setup

Step 1: Install Dependencies

First, update your Pi:

sudo apt update && sudo apt upgrade -y

Install required packages:

sudo apt install build-essential git cmake libhamlib-dev libwxgtk3.0-gtk3-dev libconfig++-dev libfftw3-dev libpulse-dev libusb-1.0-0-dev libudev-dev libasound2-dev

Step 2: Install pat — the Winlink Client

pat is a cross-platform Winlink client written in Go, ideal for headless or GUI-less systems like the Raspberry Pi.

Install Go (if not installed):

sudo apt install golang-go

Clone and build pat:

cd ~
git clone https://github.com/la5nta/pat.git
cd pat
go build
sudo cp pat /usr/local/bin/

Verify:

pat version

Step 3: Configure pat

Create config directory:

mkdir -p ~/.config/pat
nano ~/.config/pat/config.json

Paste and edit this basic configuration:

{
  "mycall": "9M2PJU",
  "secure_login_password": "your_winlink_password",
  "locator": "OJ03pa",
  "listen": ["http"],
  "http_addr": "0.0.0.0:8080"
}

Replace 9M2PJU with your callsign, and set your password. The locator can be your Maidenhead grid square.

Step 4: Connect Radio & Sound Interface

Connect your USB soundcard interface to the Pi and your transceiver. Make sure audio in/out is working (check with arecord and aplay).

Optional: Configure audio devices in ~/.asoundrc or set defaults with alsamixer.

Step 5: Install ardop or ax25 Modem

Install ARDOP (for VHF/UHF or HF soundcard modes)

Clone and build:

cd ~
git clone https://github.com/la5nta/ardop.git
cd ardop
go build
sudo cp ardop /usr/local/bin/

Step 6: Launch pat Web Interface

Run the client:

pat http

On your browser, navigate to:

http://<raspberrypi-ip>:8080

You’ll see the Winlink pat interface. You can compose messages, connect to gateways, and send emails over RF.

Step 7: Send and Receive Messages

To send a message:

1. Click Compose
2. Enter recipient (e.g., yourname@winlink.org)
3. Choose Winlink CMS Relay for direct messages or Packet/ARDOP for RF
4. Click Send

To send via RF (Packet or ARDOP), you’ll need to set up modems and gateway frequencies. Example (packet mode):

pat connect ax25 KLSAR-10

Or ARDOP:

pat connect ardop K4CJX

Tips and Tricks

• Use tmux or screen to keep pat running in the background
• Install ax25-tools if using hardware TNC
• Use direwolf for software packet TNC (AX.25 mode)
• Set up a cronjob to auto-launch on boot

Security Note

The web interface doesn’t use SSL by default. If you’re exposing this over a network, consider using SSH tunneling or a reverse proxy with HTTPS.

Final Thoughts

With just a Raspberry Pi and some ham radio gear, you now have a fully functional Winlink station capable of handling email over RF. This setup is portable, reliable, and an excellent asset for both casual and emergency use.

The post How to Set Up a Winlink Client on a Raspberry Pi appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

As radio amateurs, integrating real-world sensor data into APRS can be both useful and fun. In this guide, I’ll show you how to use a Bash script to automatically fetch your local weather data from OpenWeatherMap and send it to the APRS-IS network.

This method is especially useful for stations that don’t have a dedicated weather station but want to share weather conditions based on their location.

What You’ll Need

• A Linux machine or server (I’m using Debian)
• Your APRS callsign and passcode
• An OpenWeatherMap API key (free)
• Coordinates of your QTH
• jq and netcat installed

Step 1: Get Your API Keys

APRS-IS Passcode

If you don’t already have a passcode, you can generate it based on your callsign. For example, you can use my free generator here:

https://pass.hamradio.my

OpenWeatherMap API Key

1. Go to https://openweathermap.org/api
2. Sign up for a free account.
3. Copy your API key from the dashboard.

Step 2: Determine Your Coordinates

You’ll need your latitude and longitude in decimal format.

Example for Kuala Lumpur:

• Latitude: 3.1390
• Longitude: 101.6869

Step 3: The Bash Script

Here’s the full script:

#!/bin/bash

# === USER CONFIGURATION ===
CALLSIGN="PJUWX-13"                   # Your APRS callsign (with SSID)
PASSCODE="12031"                      # Your APRS-IS passcode
LAT="3.1390"                          # Latitude (decimal format)
LON="101.6869"                        # Longitude (decimal format)
OPENWEATHER_API_KEY="your_api_key"   # Replace with your OpenWeatherMap API key
SERVER="rotate.aprs2.net"            # APRS-IS server
PORT="14580"                          # APRS-IS port
COMMENT="9M2PJU WX Station 🐧"       # Comment sent with weather data

# === FETCH WEATHER DATA ===
weather_json=$(curl -s "https://api.openweathermap.org/data/2.5/weather?lat=$LAT&lon=$LON&units=metric&appid=$OPENWEATHER_API_KEY")
temp=$(echo "$weather_json" | jq '.main.temp' | xargs printf "%.0f")
humidity=$(echo "$weather_json" | jq '.main.humidity')
pressure=$(echo "$weather_json" | jq '.main.pressure')

# === FORMAT WEATHER PACKET ===
lat_aprs=$(printf "%02d%05.2fN" "${LAT%.*}" "$(echo "${LAT#*.} * 60 / 1" | bc -l)")
lon_aprs=$(printf "%03d%05.2fE" "${LON%.*}" "$(echo "${LON#*.} * 60 / 1" | bc -l)")

WX_PACKET="${CALLSIGN}>APRS,TCPIP*:@$(date -u +%d%H%Mz)!${lat_aprs}/${lon_aprs}_.../...g...t$(printf "%03d" $temp)r...p...P...h${humidity}b$(printf "%05d" $((pressure * 10))) ${COMMENT}"

# === SEND TO APRS-IS ===
(
echo "user $CALLSIGN pass $PASSCODE vers PJUWX-Bash 1.0"
echo "$WX_PACKET"
sleep 1
) | nc "$SERVER" "$PORT"

echo "✅ Sent: $WX_PACKET"

Save this as send_weather_aprs.sh, and make it executable:

chmod +x send_weather_aprs.sh

What This Script Does

1. Fetches Weather Data from OpenWeatherMap using your coordinates and API key.
2. Extracts:
   • Temperature (°C)
   • Humidity (%)
   • Pressure (hPa)
3. Formats your position in APRS format (degrees and minutes).
4. Builds an APRS packet with a weather report.
5. Sends the packet using Netcat (nc) to the APRS-IS network.

Automate It with Cron (Optional)

To send updates every 20 minutes, add it to your crontab:

crontab -e

Then add:

*/20 * * * * /path/to/send_weather_aprs.sh

Example APRS Packet

PJUWX-13>APRS,TCPIP*:@220945z0313.14N/10141.21E_.../...g...t031r...p...P...h78b10032 9M2PJU WX Station 🐧

Things to Improve

This is a simple example to get you started. You could extend this by:

• Adding wind speed and direction
• Including rainfall (requires API with more data or sensors)
• Sending packets via RF using a TNC instead of APRS-IS
• Switching to Python for better formatting and error handling

Conclusion

This script is a lightweight, no-hardware solution to send real-time weather data to APRS using just Bash and a public API. Whether you’re setting up a portable station or just want to contribute environmental data from your QTH, this is a great way to get started.

Feel free to modify, share, or expand upon it!

The post Sending Weather Data to APRS-IS Using Bash and OpenWeatherMap API appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re looking for a low-power, always-on solution for streaming your personal media library, the Raspberry Pi makes a great Plex server. It’s compact, quiet, affordable, and perfect for handling basic media streaming—especially for home use.

In this post, I’ll guide you through setting up Plex Media Server on a Raspberry Pi, using Raspberry Pi OS (Lite or Full) or Debian-based distros like Ubuntu Server.

What You’ll Need

• Raspberry Pi 4 or 5 (at least 2GB RAM, 4GB+ recommended)
• microSD card (32GB+), or SSD via USB 3.0
• External storage for media (USB HDD/SSD or NAS)
• Ethernet or Wi-Fi connection
• Raspberry Pi OS (Lite or Desktop)
• A Plex account (free is enough)

Step 1: Prepare the Raspberry Pi

1. Flash Raspberry Pi OS using Raspberry Pi Imager
2. Enable SSH and set hostname (optional)
3. Boot the Pi, log in, and update:

sudo apt update && sudo apt upgrade -y

Step 2: Install Plex Media Server

Plex is available for ARM-based devices via their official repository.

1. Add Plex repo and key:

curl https://downloads.plex.tv/plex-keys/PlexSign.key | sudo apt-key add -
echo deb https://downloads.plex.tv/repo/deb public main | sudo tee /etc/apt/sources.list.d/plexmediaserver.list
sudo apt update

2. Install Plex:

sudo apt install plexmediaserver -y

Step 3: Enable and Start the Service

Enable Plex on boot and start the service:

sudo systemctl enable plexmediaserver
sudo systemctl start plexmediaserver

Make sure it’s running:

sudo systemctl status plexmediaserver

Step 4: Access Plex Web Interface

Open your browser and go to:

http://<your-pi-ip>:32400/web

Log in with your Plex account and begin the setup wizard.

Step 5: Add Your Media Library

Plug in your external HDD or mount a network share, then:

sudo mkdir -p /mnt/media
sudo mount /dev/sda1 /mnt/media

Make sure Plex can access it:

sudo chown -R plex:plex /mnt/media

Add the media folder during the Plex setup under Library > Add Library.

Optional Tips

• Transcoding: The Pi can handle direct play (no transcoding) well, but struggles with transcoding large files. Use compatible formats like H.264 (MP4).
• USB Boot: For better performance, boot the Pi from an SSD instead of a microSD card.
• Power Supply: Use a proper 5V/3A PSU to avoid crashes under heavy disk load.
• Thermal: Add a heatsink or fan for the Pi if using Plex for long sessions.

Secure Your Server

• Use your router to forward port 32400 only if you want remote access.
• Set a strong Plex password.
• Enable Tailscale or WireGuard for secure remote access without exposing ports.

Conclusion

A Raspberry Pi might not replace a full-blown NAS or dedicated server, but for personal use or as a secondary Plex node, it’s surprisingly capable. With low energy usage and silent operation, it’s the perfect DIY home media solution.

If you’re running other services like Pi-hole or Home Assistant, the Pi can multitask well — just avoid overloading it with too much transcoding.

The post Building a Plex Media Server with Raspberry Pi appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In an age where speed, scalability, and automation are king, traditional networking methods are struggling to keep up with the demands of modern IT systems. Enter Software-Defined Networking (SDN)—a paradigm shift that is revolutionizing how networks are designed, managed, and optimized.

Whether you’re a systems engineer, network admin, or just someone curious about emerging tech, SDN is worth understanding. Here’s a comprehensive overview of what SDN is, where it came from, how it works, and its pros and cons.

What is Software-Defined Networking?

At its core, Software-Defined Networking (SDN) is an architectural approach that separates the control plane (the “brain” that decides how data flows) from the data plane (the part that actually moves the data).

Traditionally, each switch or router in a network independently makes its own decisions about traffic. With SDN, those decisions are centralized in a controller, a software-based system that oversees and manages the entire network’s traffic.

SDN In Simple Terms:

Think of SDN as remote-controlled networking—you manage and automate how traffic moves from a single central interface, rather than configuring each device individually.

A Brief History of SDN

The concept of SDN was born in academia. Around 2008, researchers at Stanford University and UC Berkeley developed a protocol called OpenFlow—a way to remotely program the behavior of network switches.

The movement gained commercial traction with the formation of the Open Networking Foundation (ONF) in 2011, backed by tech giants like Google, Microsoft, Facebook, and Verizon. Since then, SDN has become integral to cloud computing, data centers, and service provider networks.

Key Components of an SDN Architecture

1. SDN Controller (Control Plane):
   • The centralized brain of the network.
   • Examples: OpenDaylight, ONOS, Cisco APIC.
2. Network Devices (Data Plane):
   • These are the switches/routers that forward packets based on instructions from the controller.
3. Southbound APIs (e.g., OpenFlow):
   • Used by the controller to communicate with devices.
4. Northbound APIs:
   • Used by applications or administrators to program and control the network behavior.

SDN Architecture Diagram

Here’s a simple diagram to help visualize how SDN works:

          [ Applications / Management Tools ]
                      ↑ (Northbound API)
               [ SDN Controller ]
              ↑                     ↓
     (Southbound API)     (Control Instructions)
         [ Network Switches / Routers ]
                      ↓ (Forwarding Data)
                 [ End Users / Devices ]

How SDN Works

In a traditional network, each router and switch needs to be configured individually. In SDN:

• All devices are managed centrally.
• Traffic can be rerouted or optimized in real-time.
• Policies can be defined using software and implemented instantly.

This abstraction gives engineers powerful control and visibility over the entire network infrastructure.

Advantages of SDN

1. Centralized Management

All configuration and traffic policies are managed through a single controller, reducing complexity.

2. High Agility & Flexibility

Networks can adapt in real-time to changes in traffic, demand, or failures.

3. Programmability

Developers and network admins can write scripts or apps to control traffic dynamically, improving automation and efficiency.

4. Cost Efficiency

SDN allows the use of inexpensive commodity hardware, reducing dependency on costly proprietary gear.

5. Improved Network Visibility

With centralized control, it’s easier to monitor traffic, detect bottlenecks, and enforce security policies.

6. Rapid Innovation

Network functions like load balancing, firewalling, or routing can be updated through software without changing hardware.

Disadvantages of SDN

1. Security Risks in the Controller

Centralizing the control plane introduces a single point of failure. If the controller is compromised, the whole network is at risk.

2. Complex Migration

Transitioning from a traditional network to SDN can be technically challenging and may require significant investment and retraining.

3. Interoperability Issues

Varying vendor implementations and lack of standardization can lead to compatibility problems in multi-vendor environments.

4. Latency Concerns

Some centralized decisions may introduce delays, especially in large-scale or high-frequency environments.

Real-World Use Cases

Data Centers

Major cloud providers like Google, AWS, and Microsoft Azure use SDN to scale and manage massive infrastructure.

5G & Telecom Networks

SDN enables network slicing and efficient spectrum allocation in next-gen mobile networks.

Enterprises

Businesses use SDN in SD-WAN deployments to manage traffic across multiple branch offices efficiently.

Network Function Virtualization (NFV)

SDN complements NFV by enabling virtualized firewalls, routers, and load balancers.

Popular SDN Tools & Platforms

Try SDN at Home: Lab Ideas

If you’re interested in getting hands-on with SDN, here are a few ideas to get started:

1. Mininet

• Lightweight network emulator for testing SDN.
• Can simulate thousands of hosts using virtual machines.
• Website: mininet.org

2. GNS3 or EVE-NG with OpenFlow switches

• Useful for more visual or drag-and-drop style labs.
• Combine OpenFlow-capable devices with SDN controllers.

3. OpenDaylight Sandbox

• Try the OpenDaylight controller in a virtual environment.
• Build REST API apps to dynamically modify network behavior.

4. Raspberry Pi SDN

• Use Raspberry Pi boards as lightweight SDN switches for home labs.
• Combine with Python scripts to test programmable networking.

Final Thoughts

SDN is not just a buzzword—it’s a foundational technology that powers the modern internet and cloud-based services. While it comes with its own challenges, the control, agility, and cost-efficiency it brings to networking are too significant to ignore.

If you’re a network engineer, sysadmin, or tech enthusiast, now is a great time to dive deeper into SDN. The ecosystem is still growing, and getting skilled in SDN today will place you ahead in tomorrow’s tech landscape.

The post Software-Defined Networking (SDN): The Future of Flexible Network Infrastructure appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Does your home or office internet feel sluggish, especially when multiple people are browsing? You might be surprised to learn that you can significantly improve your network’s performance by setting up a caching proxy server. In this guide, I’ll walk you through the process step-by-step.

What is a Caching Proxy Server?

A caching proxy server sits between your local network devices and the internet. It stores copies of resources (like web pages, images, and videos) that users request. When someone on your network visits a website that another user has already accessed, the proxy server delivers the cached content instead of downloading it again from the internet. This reduces bandwidth usage and improves loading times.

Benefits of Setting Up a Caching Proxy Server

• Faster browsing: Cached content loads much quicker than fresh downloads
• Reduced bandwidth consumption: The same content isn’t downloaded multiple times
• Lower latency: Local network access is always faster than internet requests
• Works for all devices: Benefits every device on your network without configuration
• Potential cost savings: If you have a metered connection, this reduces data usage

What You’ll Need

• A spare computer or Raspberry Pi (with at least 2GB RAM and 32GB storage)
• Basic networking knowledge
• 1-2 hours of setup time
• Squid proxy software (free and open-source)

Step 1: Choosing and Preparing Your Hardware

You don’t need powerful hardware for a home or small office caching proxy. A Raspberry Pi 4 works great for small networks (up to 10 devices), while a modest PC or old laptop can handle larger networks.

For this tutorial, I’ll use Ubuntu Server as the operating system, but you can use any Linux distribution.

1. Download Ubuntu Server from ubuntu.com/download/server
2. Install it on your device following the installation prompts
3. Make sure to set a static IP address during installation

Step 2: Installing Squid Proxy Server

Squid is the most popular caching proxy software. It’s powerful, reliable, and well-documented. Let’s install it:

1. Update your system:

sudo apt update
sudo apt upgrade -y

2. Install Squid:

sudo apt install squid -y

3. Verify the installation:

squid -v

This should display the Squid version information.

Step 3: Configuring Squid for Caching

The default Squid configuration works, but we need to optimize it for caching:

1. Back up the original configuration:

sudo cp /etc/squid/squid.conf /etc/squid/squid.conf.original

2. Edit the configuration file:

sudo nano /etc/squid/squid.conf

3. Find and modify these settings (or add them if not present):

# Define your local network
acl localnet src 192.168.1.0/24  # Change this to match your network

# Allow access from your local network
http_access allow localnet

# Cache settings
cache_mem 512 MB  # Adjust based on your server's RAM
maximum_object_size 50 MB  # Maximum size of objects to cache
cache_dir ufs /var/spool/squid 10000 16 256  # 10GB disk cache

# Refresh patterns for different content types
refresh_pattern ^ftp:           1440    20%     10080
refresh_pattern ^gopher:        1440    0%      1440
refresh_pattern -i (/cgi-bin/|\?) 0     0%      0
refresh_pattern \.(gif|png|jpg|jpeg|ico)$ 10080 90% 43200 override-expire ignore-no-cache ignore-no-store
refresh_pattern \.(css|js)$     10080   90%     43200 override-expire ignore-no-cache ignore-no-store
refresh_pattern .               0       20%     4320

4. Save and close the file (Ctrl+X, then Y, then Enter in nano)
5. Create the cache directory:

sudo mkdir -p /var/spool/squid
sudo chown proxy:proxy /var/spool/squid

6. Initialize the cache:

sudo squid -z

7. Restart Squid:

sudo systemctl restart squid

Step 4: Setting Up Your Network to Use the Proxy

There are two ways to implement the proxy on your network:

Option 1: Configure Each Device (Manual Method)

Configure each device to use your proxy server:

• Proxy Address: Your server’s IP address (e.g., 192.168.1.10)
• Port: 3128 (Squid’s default port)

This approach requires setting up each device individually but gives you more control.

Option 2: Configure Your Router (Transparent Proxy)

This method automatically routes all web traffic through your proxy:

1. Install additional packages:

sudo apt install iptables-persistent -y

2. Add these lines to squid.conf:

# Transparent proxy settings
http_port 3128 transparent

3. Set up IP forwarding:

echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

4. Create IPTables rules:

sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 3128
sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 3128

5. Save the rules:

sudo netfilter-persistent save

6. On your router, set the default gateway to your proxy server’s IP address

Step 5: Testing and Monitoring

1. Test basic functionality by browsing from a device on your network
2. Monitor cache performance:

tail -f /var/log/squid/access.log

3. Check cache hit rate:

squidclient mgr:info | grep "Hit Rate"

Advanced Optimizations

After you have the basic setup working, consider these optimizations:

Increase Cache Size

If you have extra storage, increase the cache size:

cache_dir ufs /var/spool/squid 20000 16 256  # 20GB disk cache

Enable HTTPS Caching

Modern websites use HTTPS. To cache this content:

1. Install SSL tools:

sudo apt install openssl -y

2. Generate certificates:

sudo mkdir -p /etc/squid/ssl_cert
sudo openssl req -new -newkey rsa:2048 -sha256 -days 365 -nodes -x509 -keyout /etc/squid/ssl_cert/myproxy.pem -out /etc/squid/ssl_cert/myproxy.pem
sudo chown proxy:proxy /etc/squid/ssl_cert/myproxy.pem

3. Add to squid.conf:

# HTTPS caching
https_port 3129 cert=/etc/squid/ssl_cert/myproxy.pem ssl-bump intercept
acl SSL_port port 443
acl CONNECT method CONNECT
http_access allow CONNECT SSL_port localnet
ssl_bump server-first all
sslcrtd_program /usr/lib/squid/security_file_certgen -s /var/lib/ssl_db -M 4MB
sslcrtd_children 5

4. Create the SSL database:

sudo mkdir -p /var/lib/ssl_db
sudo chown -R proxy:proxy /var/lib/ssl_db

5. Restart Squid:

sudo systemctl restart squid

6. Install the generated certificate on your devices as a trusted CA

Troubleshooting Common Issues

1. Squid not starting: Check logs with sudo journalctl -u squid
2. Slow performance: Verify disk cache is working with ls -la /var/spool/squid/
3. Websites not loading: Ensure your network configuration is correct
4. HTTPS issues: Check certificate installation

Conclusion

Setting up a caching proxy server can significantly improve your network’s browsing experience. While the initial setup requires some technical knowledge, the long-term benefits are substantial. Your internet will feel faster, especially for frequently visited sites, and you’ll save bandwidth in the process.

Have you set up a caching proxy server? Share your experience in the comments below!

Disclaimer: This setup is intended for home or small office networks. For enterprise environments, consider professional solutions with support contracts.

The post How to Set Up a Caching Proxy Server to Speed Up Your Local Network appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re using Linux today — whether on a desktop, server, or embedded device — there’s a good chance the foundation of your system can be traced back to Debian. Debian is one of the oldest, most respected, and most influential GNU/Linux distributions ever created. It has quietly shaped the digital world around us — from powering large-scale web servers and scientific clusters to forming the basis of popular distributions like Ubuntu, Raspbian, and countless others.

But Debian is more than just a technical achievement. It is a social, ethical, and political project — one rooted in the ideals of freedom, transparency, and community governance.

This article takes a detailed journey through Debian’s origins, evolution, and its unique capabilities in desktop and server environments — and highlights why Debian is a perfect match for amateur radio operators.

The Origin of Debian: A Manifesto Becomes a Movement

In the early 1990s, the Linux kernel was still a new and evolving project. While Linus Torvalds was actively developing the kernel itself, various individuals and small groups were creating their own Linux distributions. These early distributions were often difficult to maintain, poorly documented, and inconsistent.

Enter Ian Murdock, a young computer science student at Purdue University. On August 16, 1993, he released the Debian Manifesto, which laid out a bold vision: a completely free, open, and community-developed operating system that adhered to the values of the Free Software Foundation.

He named it “Debian” — a portmanteau of his name and that of his then-girlfriend, Debra.

From the beginning, Debian sought to be different:

• It would not be controlled by a single person or company.
• It would emphasize openness, stability, and quality.
• It would be built by volunteers and for the community.

Debian was not only a software project — it was a social contract, a movement, and a model for how free software could be built cooperatively.

Historical Milestones: Debian Through the Years

1993–1995: The Early Days

Debian 0.91 was the first version that gained traction, introducing the .deb package format and the dpkg package manager. From the start, Debian aimed to be modular, reliable, and secure.

1996: The Birth of APT

One of Debian’s greatest innovations was the introduction of APT (Advanced Package Tool) — a front-end that made it easier to install, upgrade, and remove software while managing dependencies automatically. This was a huge leap over what other distributions offered at the time.

Late 1990s: A Social and Ethical Framework

Debian formalized its values through documents like:

• The Debian Social Contract
• The Debian Free Software Guidelines (DFSG)
• The Debian Constitution

These were radical moves. Debian became the first Linux distribution to explicitly define its governance, its commitment to users, and its ethical foundations.

2000s–2010s: Becoming a Foundation for the World

Debian’s popularity surged. It became the base for:

• Ubuntu
• Raspbian (now Raspberry Pi OS)
• Kali Linux
• Linux Mint (Debian Edition)
• Countless server deployments in enterprises and universities

Debian evolved to support multiple CPU architectures, introduced udev for dynamic device management, and transitioned to systemd in later years for improved boot and service handling.

Today, Debian is developed by over 1,000 active developers, with tens of thousands of contributors and mirror servers in almost every country on Earth.

Debian on the Desktop: A Powerhouse of Possibility

Although Debian has a reputation as a server distribution, it is equally capable as a desktop system, especially for users who value stability, freedom, and control.

Why Choose Debian for Desktop Computing?

1. Unmatched Stability

Debian’s “Stable” release is tested for months, sometimes years, before finalization. This makes it ideal for users who prioritize reliability over bleeding-edge features.

2. Custom Desktop Environments

Whether you prefer GNOME, KDE Plasma, XFCE, LXQt, Mate, Cinnamon, or even minimalist setups like i3wm, Debian allows full flexibility during installation.

3. Freedom From Bloatware

Unlike commercial operating systems that come pre-loaded with unnecessary software and background tracking, Debian installs only what you choose — nothing more.

4. Vast Software Library

With more than 59,000 precompiled packages, almost every piece of software you could need is available directly via apt. From graphic design and media editing to office work and development tools — Debian has it all.

5. Privacy and Security

Debian has no telemetry. It does not collect or transmit user data, ever. Plus, it receives security updates from a dedicated security team that supports each Stable release for five years or more.

6. Perfect for Developers and Hackers

Debian is an ideal workstation for programmers, sysadmins, researchers, and makers. It supports development tools in C, Python, Rust, Go, Java, and more — all easily installable through the package manager.

Debian as a Server: The Gold Standard of Stability

When it comes to deploying mission-critical applications, few operating systems are as trusted as Debian.

Why Debian Dominates Server Rooms

1. Long-Term Stability

Debian’s conservative release cycle ensures that servers can run for years without interruption, even through major upgrades.

2. Excellent Security Practices

Debian takes security seriously. With signed packages, trusted repositories, and an active security team, administrators can sleep better knowing their systems are protected.

3. Universal Hardware Support

From Raspberry Pis to enterprise-grade x86 servers, from old legacy boxes to modern ARM64 devices — Debian supports them all.

4. Container and Virtualization Ready

Debian is the default base image for Docker containers, is heavily used in cloud infrastructure, and runs perfectly on KVM, Xen, LXC, and VMware.

5. Flexible Roles

Debian can easily be configured as:

• Web server (Apache, NGINX)
• Mail server (Postfix, Dovecot)
• DNS server (BIND, Unbound)
• Database server (PostgreSQL, MySQL, MariaDB)
• File server (Samba, NFS)
• VPN (WireGuard, OpenVPN)

6. Efficient Resource Usage

Without bloated GUIs or unnecessary background services, Debian performs faster and lighter than most alternatives. It’s ideal for headless systems and energy-efficient servers.

Debian for Amateur Radio Operators: A Perfect Match

How Debian Enhances Ham Radio Operations

1. Wide Selection of Ham Software

Debian’s repository includes a treasure trove of amateur radio tools:

• AX.25 and APRS: ax25-tools, direwolf, xastir, aprx
• Digital Modes: flrig, fldigi, wsjtx, js8call, qsstv
• Logging and Contesting: tlf, xlog, cqrlog
• Packet Radio and Winlink: pat, linpac, soundmodem
• Satellite Tracking: gpredict

No need to compile from source — just install with apt.

2. Runs on Low-Power Devices

Debian is lightweight and can run on Raspberry Pi, Odroid, or old laptops — perfect for portable stations, field days, and emergency communications.

3. Custom Automation and Gateways

You can build your own:

• APRS iGate or Digipeater
• LoRa gateways
• Remote HF control stations
• Telemetry collection systems

With scripting and cron jobs, you can automate nearly everything.

4. Stable Uptime for Remote Stations

Need a node to run unattended in a rural area? Debian’s reputation for rock-solid uptime is exactly what hams need for off-grid repeaters, gateways, or remote logging setups.

5. Hackable and Modular

Debian doesn’t get in your way. You can build exactly the shack system you want — and even write your own software, drivers, or tools using Python, Bash, or C.

Conclusion: Why Debian Should Be Your OS of Choice

Whether you’re a sysadmin, hobbyist, student, ham radio operator, or casual Linux user, Debian has something for you.

• It’s ethically grounded, built by a global community, and entirely free.
• It powers desktops, laptops, servers, cloud platforms, and IoT devices with equal confidence.
• It respects your freedom, your time, and your intelligence.
• And for the amateur radio community, it is the perfect companion in the shack.

If you haven’t tried Debian yet, now’s the time. Download the ISO, write it to a USB drive, and join the movement that’s been quietly powering the internet, science, and innovation for over 30 years.

Debian isn’t just a Linux distro. It’s the soul of free software.

The post The Story of Debian: From Hacker Roots to Global Impact appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In the digital age, accurate timekeeping is more critical than ever. From ensuring data consistency across global servers to enabling GPS navigation and military operations, the precision of our clocks underpins modern infrastructure. This post explores how Network Time Protocol (NTP), atomic clocks, and the Global Positioning System (GPS) work together to synchronize time around the world—and what stratum levels really mean in timekeeping hierarchy.

What Is Network Time Protocol (NTP)?

NTP (Network Time Protocol) is a protocol used to synchronize the clocks of computers and devices over a network. It allows systems to keep time within milliseconds of Coordinated Universal Time (UTC), which is the global time standard.

NTP works using a hierarchical structure of stratum levels, with each level representing the “distance” from the reference clock (usually an atomic clock or GPS-based source).

How NTP Works

Here’s a simplified overview of the process:

1. A client computer sends a request to an NTP server.
2. The NTP server responds with the current time along with information about when the request was received and replied to.
3. The client calculates the round-trip delay and clock offset.
4. The local clock is adjusted accordingly, either gradually or immediately.

This process often repeats at regular intervals to maintain synchronization.

Understanding NTP Stratum Levels

NTP servers are organized into strata based on how close they are to the original time source:

• Stratum 0: These are the reference clocks—usually atomic clocks, GPS receivers, or radio clocks. They don’t connect directly to the internet.
• Stratum 1: Servers directly connected to stratum 0 devices. These are often publicly available NTP servers and offer highly accurate time.
• Stratum 2: Servers that sync with stratum 1 servers. Most users rely on these.
• Stratum 3–15: Each additional level syncs from the level above, with increasing latency and reduced accuracy.
• Stratum 16: Designated for unsynchronized servers or devices.

Example:
If your Raspberry Pi is syncing from time.google.com (a stratum 1 server), your device becomes a stratum 2 client.

What Is an Atomic Clock?

An atomic clock is the most precise timekeeping device available. It uses the natural oscillations of atoms—commonly cesium-133 or rubidium—as a reference.

Key Characteristics:

• Accuracy: Can measure time with precision better than 1 second in millions of years.
• Stability: Remains extremely consistent over long periods.
• Use Cases: GPS satellites, NTP stratum 0 devices, scientific labs, telecom networks.

The international definition of one second is based on the radiation cycles of cesium-133:
9,192,631,770 transitions = 1 second

How GPS Provides Accurate Time

The Global Positioning System (GPS) is not just for navigation—it’s also a precise time distribution network. Each GPS satellite contains multiple atomic clocks. When your GPS receiver locks onto satellites, it can:

• Determine location using trilateration
• Calculate the exact time from satellite signals

GPS Time vs UTC:

• GPS time started in 1980 and does not account for leap seconds, unlike UTC.
• GPS receivers convert GPS time to UTC using data in the satellite’s almanac.

For time servers, GPS receivers act as Stratum 0 sources, making GPS-based NTP servers (Stratum 1) popular for time-critical systems.

Real-World Applications

When Accuracy Matters

A tiny time drift can cause:

• Log mismatch in security systems
• Transaction failures in banking
• Packet loss or desync in VoIP and online gaming
• Routing issues in network infrastructure

Thus, reliable NTP configuration, ideally syncing from multiple stratum 1 servers or running your own GPS-based server, is best practice for critical systems.

Summary

Together, atomic clocks, GPS, and NTP form a robust global timekeeping system that powers everything from Google’s servers to battlefield operations and your APRS messages.

Build Your Own Stratum 1 NTP Server (Raspberry Pi + GPS + Chrony)

Creating your own Stratum 1 NTP server is a rewarding project, especially for ham radio operators, makers, and sysadmins who want reliable, low-latency timekeeping without relying on the internet.

What You Need:

• Raspberry Pi (any model with GPIO, preferably Pi 3/4/5)
• GPS module with PPS (Pulse Per Second) output (e.g. u-blox NEO-6M or NEO-M8N)
• Serial connection to GPS (UART)
• Internet for installation (optional afterward)
• Linux with chrony, gpsd, and PPS support

Step 1: Hardware Setup

1. Connect the GPS module:
   • TX (GPS) to GPIO 15 (RXD) on the Pi
   • PPS pin to GPIO 18 (Pin 12)
   • VCC and GND appropriately
2. Enable UART and PPS on the Pi: sudo raspi-config
   • Interface Options → Enable Serial (disable console over serial, enable hardware UART)
   • Reboot when prompted.

Step 2: Install Required Packages

sudo apt update
sudo apt install gpsd gpsd-clients chrony pps-tools

Step 3: Enable and Test PPS

1. Add the PPS overlay:

Edit /boot/config.txt and add:

dtoverlay=pps-gpio,gpiopin=18

2. Reboot:

sudo reboot

3. Check if /dev/pps0 appears:

ls -l /dev/pps*

4. Test PPS signal:

sudo ppstest /dev/pps0

You should see output like:

source 0 - assert 1716165796.000000000, sequence: 1234 - clear 1716165796.000001234

Step 4: Configure GPSD

Edit /etc/default/gpsd:

START_DAEMON="true"
DEVICES="/dev/serial0"
GPSD_OPTIONS="-n"

Restart the service:

sudo systemctl restart gpsd

Verify:

cgps -s

You should see satellite data and GPS time.

Step 5: Configure Chrony for GPS + PPS

Edit /etc/chrony/chrony.conf and add these lines at the top:

refclock SHM 0 offset 0.5 delay 0.2 refid GPS
refclock PPS /dev/pps0 refid PPS lock GPS

Also, comment out any existing pool or server lines if you want it to be completely standalone.

Restart Chrony:

sudo systemctl restart chrony

Step 6: Verify Chrony Status

chronyc sources -v

You should see entries like:

#x  Name/IP address            Stratum  Poll Reach  LastRx Last sample
===============================================================================
#?  GPS                          0       4   377     10     -4ns[  +23ns] +/- 30us
#*  PPS                          0       4   377     9      -1ns[   -5ns] +/- 0.1us

The * next to PPS indicates it’s the preferred source.

🖧 Optional: Share NTP on Your Network

Edit /etc/chrony/chrony.conf to allow LAN clients:

allow 192.168.1.0/24

Replace with your local subnet. Restart Chrony to apply.

This allows you to sync your entire home lab or shack with millisecond precision without depending on the internet.

The post Understanding Network Time Protocol (NTP), Atomic Clocks, and GPS: How Precise Timekeeping Powers the Modern World appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Interested in getting into amateur radio, but not licensed yet? You can start listening to your local repeater activity using a Raspberry Pi, an RTL-SDR USB dongle, and a simple external speaker — all without transmitting a single signal.

In this post, I’ll walk you through how to set up the RTL-SDR, connect it to an external speaker, and listen in to real amateur radio conversations. It’s a great way to learn, get familiar with local activity, and prepare for your amateur radio examination.

What You’ll Need

• Raspberry Pi 3, 4, or Zero 2 W (with Raspberry Pi OS)
• RTL-SDR USB dongle (e.g., RTL2832U chipset)
• Internet access (for setup)
• 3.5mm audio speaker or powered USB speaker
• Basic VHF/UHF antenna (or better)

Optional:

• External case/cooler for the RTL-SDR
• Monitor and keyboard (or SSH access)

Step 1: Install Required Software

Open a terminal on your Raspberry Pi and install the RTL-SDR tools:

sudo apt update && sudo apt upgrade -y
sudo apt install rtl-sdr sox pulseaudio pavucontrol

Install gqrx if you want a GUI receiver (optional but requires desktop environment):

sudo apt install gqrx-sdr

Step 2: Test the RTL-SDR Dongle

Before going further, plug in your RTL-SDR and test detection:

rtl_test

If you see something like Found 1 device(s), you’re good to go.

If you see a message about a conflicting DVB driver, disable it:

sudo nano /etc/modprobe.d/no-rtl.conf

Add:

blacklist dvb_usb_rtl28xxu
blacklist rtl2832
blacklist rtl2830

Then reboot:

sudo reboot

Step 3: Install and Use rtl_fm to Listen

rtl_fm is a command-line tool to tune your RTL-SDR to a frequency and demodulate FM signals.

Example: To listen to a repeater at 147.000 MHz (standard NBFM):

rtl_fm -f 147M -M fm -s 22050 -r 22050 - | play -r 22050 -t raw -e s -b 16 -c 1 -

If audio is too quiet or noisy, adjust gain:

rtl_fm -f 147M -M fm -s 22050 -g 35 - | play -r 22050 -t raw -e s -b 16 -c 1 -

You can replace 147M with the frequency of your local repeater (see next section).

Step 4: Find Your Nearest Repeaters

You can find repeater info at:

• https://www.repeaterbook.com (worldwide)
• Alternatively, scan VHF band (144–148 MHz) using gqrx or rtl_power

Step 5: Use an External Speaker

If you’re using a 3.5mm analog speaker:

• Make sure audio is not muted
• Set output to headphone or 3.5mm jack:

sudo raspi-config

Select System Options > Audio > 3.5mm jack

For USB speakers, use:

pavucontrol

And route audio to your USB device.

Step 6: Automate with a Simple Script

Create a file called listen-repeater.sh:

#!/bin/bash
FREQ="147M"  # Change this to your local repeater
GAIN=35
rtl_fm -f $FREQ -M fm -s 22050 -g $GAIN - | play -r 22050 -t raw -e s -b 16 -c 1 -

Make it executable:

chmod +x listen-repeater.sh
./listen-repeater.sh

Why This Is Perfect for Beginners

• No license is needed to receive amateur radio
• You learn common repeater etiquette and callsigns
• Helps familiarize you with how hams talk, what equipment they use, and the structure of QSOs

Once licensed, you’ll already know your local frequencies, who’s active, and how to engage — making your first QSO less intimidating!

Tips

• Use a better antenna to improve reception — even a mag-mount antenna placed near a window helps
• Monitor repeater nets to learn procedure and voice flow
• Try decoding digital modes later with tools like multimon-ng or fldigi

Ready to Get On the Air?

Listening to local repeaters is the gateway to amateur radio. Using an RTL-SDR with a Raspberry Pi is an affordable, educational way to immerse yourself in the hobby before you even get your license. Once you’re ready, take the exam, get your callsign, and join the conversation.

The post How to Use an RTL-SDR with a Raspberry Pi to Listen to Amateur Radio Repeaters appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Before container technologies like Docker came into play, applications were typically run directly on the host operating system—either on bare metal hardware or inside virtual machines (VMs). While this method works, it often leads to frustrating issues, especially when trying to reproduce setups across different environments.

This becomes even more relevant in the amateur radio world, where we often experiment with digital tools, servers, logging software, APRS gateways, SDR applications, and more. Having a consistent and lightweight deployment method is key when tinkering with limited hardware like Raspberry Pi, small form factor PCs, or cloud VPS systems.

The Problem with Traditional Software Deployment

Let’s say you’ve set up an APRS iGate, or maybe you’re experimenting with WSJT-X for FT8, and everything runs flawlessly on your laptop. But the moment you try deploying the same setup on a Raspberry Pi or a remote server—suddenly things break.

Why?

Common culprits include:

• Different versions of the operating system
• Mismatched library versions
• Varying configurations
• Conflicting dependencies

These issues can be particularly painful in amateur radio projects, where specific software dependencies are critical, and stability matters for long-term operation.

You could solve this by running each setup inside a virtual machine, but VMs are often overkill—especially for ham radio gear with limited resources.

Enter Docker: The Ham’s Best Friend for Lightweight Deployment

Docker is an open-source platform that allows you to package applications along with everything they need—libraries, configurations, runtimes—into one neat, portable unit called a container.

Think of it like packaging up your entire ham radio setup (SDR software, packet tools, logging apps, etc.) into a container, then being able to deploy that same exact setup on:

• A Raspberry Pi
• A cloud server
• A homelab NUC
• Another ham’s machine

Why It’s Great for Hams:

• Lightweight – great for Raspberry Pi or low-power servers
• Fast startup – ideal for services that need to restart quickly
• Reproducible environments – makes sharing setups with fellow hams easier
• Isolation – keeps different radio tools from interfering with each other

Many amateur radio tools like Direwolf, Xastir, Pat (Winlink), and even JS8Call can be containerized, making experimentation safer and more efficient.

Virtual Machines: Still Relevant in the Shack

Virtual Machines (VMs) have been around much longer and still play a crucial role. Each VM acts like a complete computer, with its own OS and kernel, running on a hypervisor like:

• VirtualBox
• VMware
• KVM
• Hyper-V

With VMs, you can spin up an entire Windows or Linux machine, perfect for:

• Running legacy ham radio software (e.g., old Windows-only apps)
• Simulating different operating systems for testing
• Isolating potentially unstable setups from your main system

However, VMs require more horsepower. They’re heavy, boot slowly, and take up more disk space—often not ideal for small ham radio PCs or low-powered nodes deployed in the field.

Quick Comparison: Docker vs Virtual Machines for Hams

Ham Radio Use Cases for Docker

Here’s how Docker fits into amateur radio workflows:

• Run an APRS iGate with Direwolf and YAAC in isolated containers.
• Deploy SDR receivers like rtl_433, OpenWebRX, or CubicSDR as containerized services.
• Set up a Winlink gateway using Pat + ax25 tools, all in one container.
• Automate and scale your APRS bot, or APRS gateway using Docker + cron + scripts.

Docker makes it easier to test and share these setups with other hams—just export your Docker Compose file or image.

When to Use Docker, When to Use a VM

Use Docker if:

• You’re building or experimenting with modern ham radio apps
• You want to deploy quickly and repeatably
• You’re using Raspberry Pi, VPS, or low-power hardware
• You’re setting up CI/CD pipelines for your scripts or bots

Use VMs if:

• You need to run legacy apps (e.g., old Windows logging software)
• You want to simulate full system environments
• You’re working on something that could crash your main system

Final Thoughts

Both Docker and VMs are powerful tools that have a place in the modern ham shack. Docker offers speed, portability, and resource-efficiency—making it ideal for deploying SDR setups, APRS bots, or automation scripts. VMs, on the other hand, still shine when you need full system emulation or deeper isolation.

At the end of the day, being a ham means being an experimenter. And tools like Docker just give us more ways to explore, automate, and share our radio projects with the world.

The post Docker vs Virtual Machines: What Every Ham Should Know appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Software-defined radio (SDR) enthusiasts and amateur radio operators seeking an affordable yet powerful solution will find the Radioberry an exciting project to explore. Designed as a Raspberry Pi HAT, the Radioberry transforms a Raspberry Pi into a fully functional SDR transceiver, making it an excellent choice for radio experimentation and communication.

What is Radioberry?

The Radioberry is an open-source SDR transceiver designed to cover the 0-30 MHz frequency range. It leverages an Analog Devices AD9866 chipset, originally intended as a broadband modem mixed signal front-end, repurposed for Direct Down Conversion (DDC) and Direct Up Conversion (DUC) functionality. This design enables high-performance SDR capabilities with a 12-bit resolution, making it ideal for amateur radio and other radio-related applications.

At the core of the Radioberry is an Intel Cyclone 10LP FPGA, which supports 10CL16 and 10CL25 models. The FPGA firmware is dynamically loaded via the Raspberry Pi, providing a streamlined and flexible setup without the need for external programming hardware. The power supply for the Radioberry is conveniently drawn from the Raspberry Pi, simplifying the overall design and integration.

Why Choose Radioberry?

Radioberry stands out as a compelling choice for SDR enthusiasts due to its:

• Compact form factor: Seamlessly integrates with Raspberry Pi.
• Open-source philosophy: Both hardware and software are freely available.
• Cost-effective design: A budget-friendly alternative to commercial SDR solutions.
• Flexibility: Supports various modes and can be customized to meet specific needs.

Radioberry 2.x – Enhanced Performance & Features

The Radioberry 2.x builds on the original design, offering improved performance and additional features. Enthusiasts can find comprehensive details, including schematics, installation guides, and firmware updates, in the resources below.

Resources for Builders

For those interested in building their own Radioberry SDR transceiver, here are some valuable resources:

• Discussion & Community Support: Google Groups discussion forum
• Source Code & Firmware: Radioberry GitHub Repository
• Technical Documentation: Radioberry WIKI with additional information
• Installation & Setup Guide: Radioberry Releases for easy installation
• Hardware Design: Radioberry Schematic
• Real-World Applications: Radioberry transceiver insights by Gopan VU2XTO
• User Demonstrations: Recording of Radioberry 2 in action by Jacinto CU2ED

A Project for Radio Enthusiasts

The Radioberry is more than just a radio project—it’s a testament to the power of open-source collaboration and the ingenuity of the amateur radio community. This project is not for sale but rather an open-source initiative to empower builders and experimenters worldwide.

For those looking to dive into SDR development, experiment with amateur radio, or explore FPGA-based radio solutions, the Radioberry is a fantastic place to start.

Visit https://www.pa3gsb.nl/

The post Radioberry: A Raspberry Pi-Based SDR Transceiver appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Running an SVXLink node or repeater? Want real-time insights, control, and a clean web interface that just works? Meet saycharlie—a modern, open-source SVXLink dashboard built by Silviu Stroe, YO6SAY, to make managing your node easier, smarter, and way more fun.

This dashboard brings everything you love about SVXLink into one sleek browser-based UI—perfect for home labs, remote management, and repeater setups.

What is saycharlie?

saycharlie is a real-time dashboard for SVXLink—designed with ham radio operators in mind. It’s built with Python (Flask) and JavaScript (Socket.IO), offering an intuitive control panel to monitor your node, send DTMF tones, and keep tabs on who’s transmitting.

Whether you’re running a local simplex node or part of a nationwide repeater network, saycharlie puts you in control.

Key Features

• Real-Time Talker Display
  Instantly see who’s transmitting—no guesswork, just clarity.
• DTMF Code Sender
  Need to switch modules or trigger links? Just type the DTMF code and hit send.
• Remote PTT Toggle
  Control PTT with a single click—right from the dashboard.
• SVXLink Service Control
  Start, stop, or restart SVXLink without logging into the terminal.
• Callsign Lookup
  Pulls operator info from online databases so you know who’s on the other end.
• Talk Group Management
  Easily create, manage, or switch between talk groups.
• VU Meter Display
  With UDP audio stream enabled, visualize your TX/RX audio levels in real-time.
• System Info Panel
  Kernel version, CPU specs, uptime—all displayed neatly.
• Built-in Weather Widget
  Weather data based on your IP, right on the dashboard.
• Hidden Admin Menu
  Double-click on the hostname and unlock options like reboot, shutdown, and update.

Easy Setup

Installation is fast and hassle-free. Clone the repo and run the installer:

git clone https://github.com/BrainicHQ/saycharlie.git
cd saycharlie
sudo chmod +x install.sh
sudo ./install.sh

Then point your browser to http://localhost:8337 and you’re good to go.

To enable the VU meter, just configure RAW_AUDIO_UDP_DEST in your svxlink.conf. Full instructions are available in the README.

Perfect for Personal Nodes or Club Repeaters

Whether you’re managing a small Raspberry Pi node at home or a full-blown repeater site, saycharlie scales with you. The interface is clean, fast, and mobile-friendly—so you can check your system from anywhere.

If you’re serious about SVXLink, this dashboard is a game-changer. Set it up, explore the features, and enjoy a smoother, more visual radio experience.

Visit https://github.com/s1lviu/saycharlie

The post saycharlie – The Ultimate SVXLink Dashboard for Ham Radio Operators appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you have spent time setting up a Raspberry Pi with your preferred applications, configurations, and settings, it makes sense to create a backup of your SD card. This is especially useful if you need to deploy the same setup to multiple Raspberry Pi devices or if you want a quick way to restore your system in case of failure.

By creating an image of your pre-configured Raspbian SD card, you can easily clone it onto other SD cards, saving time and effort. This guide will walk you through the process of making a full backup of your SD card and restoring it when needed.

Prerequisites

Before you begin, make sure you have:

• A Linux system (or a computer with a Linux-based OS like Debian, Ubuntu, or Raspberry Pi OS).
• A properly set up Raspberry Pi SD card that you want to clone.
• A second SD card for cloning.
• An SD card reader.

Step 1: Identify the SD Card Device

First, insert your Raspberry Pi SD card into your computer and identify its device name using the following command:

lsblk

You should see a list of storage devices. Look for the one corresponding to your SD card (e.g., /dev/mmcblk0 or /dev/sdb).

Important: Ensure you select the correct device, as using the wrong one may overwrite your system disk!

Step 2: Create an Image of the SD Card

Once you’ve identified the SD card, create an image file using the dd command:

sudo dd if=/dev/sdX of=~/raspbian_backup.img bs=4M status=progress

Replace /dev/sdX with your actual SD card device (e.g., /dev/mmcblk0). This command copies the entire SD card into a single .img file.

Step 3: Compress the Image (Optional)

Since SD card images can be large, you may want to compress them to save space:

xz -z -9 ~/raspbian_backup.img

This will create raspbian_backup.img.xz, which takes up significantly less space.

Step 4: Restore the Image to Another SD Card

To clone the image onto another SD card, insert a new SD card and use the following command:

sudo dd if=~/raspbian_backup.img of=/dev/sdX bs=4M status=progress

If you compressed the image, use:

xzcat ~/raspbian_backup.img.xz | sudo dd of=/dev/sdX bs=4M status=progress

Again, replace /dev/sdX with the correct device name.

Step 5: Expand the Filesystem (If Needed)

If the new SD card has more storage than the original, you may need to expand the filesystem to use the full capacity. Boot up the Raspberry Pi and run:

sudo raspi-config

Then go to Advanced Options > Expand Filesystem, and reboot when prompted.

By following these steps, you can easily back up and clone your Raspbian setup, ensuring you never lose your custom configurations. This method is perfect for setting up multiple Raspberry Pi devices quickly or having a ready-to-use backup for future use.

Whether you’re a developer, system administrator, or Raspberry Pi hobbyist, creating SD card images will save you time and effort in managing your devices.

The post How to Clone and Backup Your Raspbian SD Card for Easy Deployment appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Are you looking for the ultimate digital radio cross patch to enhance your amateur radio experience? The Nexus DR-X, also known as DigiLink, is the Swiss Army Knife of digital radio connections. Whether you’re running Packet Radio with Direwolf, decoding signals with WSJT-X, or experimenting with Fldigi, the DR-X provides a seamless connection between your Raspberry Pi and nearly any transceiver.

Seamless Connectivity

The Nexus DR-X offers multiple connection options, making it incredibly versatile for different setups. With two audio jacks for TX and RX audio and four connection types, you can easily integrate the DR-X with a wide range of radios:

• RJ-45 with a 16-pin jumper header – Compatible with popular sound card interfaces.
• TRRS jack – Connects with off-the-shelf cables for radios supporting mic, speaker, and PTT headsets.
• Two 6-pin Mini DIN connectors – Ideal for VHF/UHF and HF radios.

This flexibility ensures that no matter your setup, the DR-X has you covered.

Powerful and Easy to Use

The DR-X kit includes a fully assembled DC-DC buck converter, which takes 7-38V input and delivers a stable 5V output. This means you can power your entire setup, including the Raspberry Pi, sound card, and DR-X, with a single power source. The board also provides 5V and 3.3V output pins, giving you even more options for expansion.

To keep your system running accurately even when offline, the kit includes an RTC module, ensuring that your Raspberry Pi maintains accurate time without an internet connection.

Run Two Radios Simultaneously

One of the standout features of the Nexus DR-X is its ability to support two radios at once. With the provided Buster Raspberry Pi image, you can operate multiple digital modes simultaneously. Imagine running FT-8 on HF while simultaneously using FSQ on VHF, or running Direwolf for APRS while decoding MT-63 on another band. The possibilities are endless!

Perfect for Clubs and Group Builds

Looking for a fantastic project for your amateur radio club? The DR-X kit is designed for group builds, making it an excellent choice for club activities. When ordering five or more kits, you receive an extra contingency kit for spare parts. If any components are misplaced during assembly, you can use the extra parts, and the manufacturer will replace them (just cover the shipping). This ensures that your club ends up with an extra unit as a bonus!

Affordable and Accessible

The Nexus DR-X kit is priced at just $49, including shipping within the U.S. If you prefer to source your own components, you can purchase the PCB alone for $14. Bulk orders are also available upon request.

Due to high demand, all units in the current batch have been reserved. Secure your spot for the next batch by placing a reservation today!

Final Thoughts

If you’re a digital radio enthusiast looking for a reliable, flexible, and powerful cross patch for your setup, the Nexus DR-X is a game-changer. With its extensive connectivity options, dual-radio capability, and easy-to-use Raspberry Pi integration, it’s the perfect tool to take your amateur radio operations to the next level.

Visit https://wb7fhc.com/nexus-dr-x.html

The post Unlock the Power of Digital Radio with the Nexus DR-X (DigiLink) appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

FreeTAKServer (FTS) is a Python3-based implementation of a TAK server designed to support situational awareness, data synchronization, mission planning, and more. In this guide, we’ll walk you through the easiest installation methods for FTS using DigitalOcean (cloud) and Raspberry Pi 4.

1. Installing FTS on DigitalOcean (Cloud)

Prerequisites:

• Create a DigitalOcean account and set up a droplet with Ubuntu 22.04 as the OS.

Installation Steps:

1. Create the Droplet:
   • In your DigitalOcean dashboard, create a new droplet. Choose Ubuntu 22.04 as the operating system.
2. Access Your Droplet:
   • Once your droplet is created, access it via SSH. Replace <your_droplet_ip> with your droplet’s IP address: ssh root@<your_droplet_ip>
3. Run the Installation Script:
   • Once logged in, execute the following command to download and run the FTS installation script: wget -qO - bit.ly/freetakhub2 | sudo bash
4. Complete the Installation:
   • The script will automatically handle the setup. Wait for it to complete, and FTS will be up and running on your droplet.
5. Access the Web Interface:
   • Once installed, you can access the FTS web administration interface by opening a browser and navigating to: http://<your_droplet_ip>:8080
   • Login with the default credentials (you may want to change them after installation).

2. Installing FTS on Raspberry Pi 4 (Single Board Computer)

Prerequisites:

• A Raspberry Pi 4 with Ubuntu 22.04 server x64 installed on an SD card.

Installation Steps:

1. Prepare Your Raspberry Pi:
   • Flash the Ubuntu 22.04 server x64 image to an SD card using a tool like Raspberry Pi Imager or Balena Etcher.
   • Insert the SD card into your Raspberry Pi 4, power it on, and connect to your network.
2. Identify the IP Address:
   • Once the Raspberry Pi is booted up, identify its IP address. You can use a tool like ifconfig or find it via your router’s admin page.
3. Set the Environment Variable:
   • Open a terminal on the Raspberry Pi and set the IP address environment variable: export MY_IPA=<your_raspberry_pi_ip_address>
4. Run the Installation Script:
   • Execute the installation command: wget -qO - bit.ly/freetakhub2 | sudo bash -s -- --ip-addr ${MY_IPA}
5. Complete the Installation:
   • The script will handle the installation process. After the script completes, your Raspberry Pi will be ready to run FTS.
6. Access the Web Interface:
   • On a browser, visit the following URL: http://<your_raspberry_pi_ip>:8080
   • You should now be able to access the FTS web interface and begin configuring your server.

3. Other Installation Methods

If you’re using another platform or need more advanced configuration options, refer to the ZeroTouch Installer documentation to customize the installation process based on your specific needs. You can find more details on this in the ZeroTouch Installer documentation.

4. Accessing the FTS Web Interface

After installation, you can access the FTS web interface by navigating to http://<server_ip>:8080 in a browser. The web interface allows you to:

• Manage users and devices
• Upload and retrieve data packages
• Configure mission planning and task lists

5. Federation and Advanced Configuration

FTS supports federation services, allowing you to connect multiple FTS instances. If you’re planning to federate your server with others, follow the steps in the Federation Service documentation.

Conclusion

Installing FreeTAKServer is straightforward, whether you’re deploying it on a cloud instance like DigitalOcean or a local Raspberry Pi 4. With its robust feature set for situational awareness, FTS provides powerful tools for managing operations and tasks in real-time. Follow the steps in this guide to get started, and explore the additional resources available on the FreeTAKServer documentation page.

If you encounter any issues, feel free to reach out to the FreeTAKTeam via their Discord server or visit their YouTube channel for tutorials and more!

The post How to Install FreeTAKServer (FTS) for Situational Awareness appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Bastille is an open-source system designed to automate the deployment and management of containerized applications on FreeBSD. Leveraging the power of FreeBSD Jails, Bastille provides a lightweight and secure way to run applications in isolated environments. Whether you’re a developer, system administrator, or security-conscious user, Bastille offers a streamlined approach to container management.

Features of Bastille

Bastille comes with a range of features that make it an excellent choice for containerized environments on FreeBSD:

• Automation Templates: Create and share container templates.
• Zero Dependencies: Lightweight and efficient.
• Highly Secure by Default: Implements strict access controls.
• Read-only Root: Protects the root user environment.
• Flexible Networking & Firewall Options: Supports various network configurations.
• Target Containers: Execute commands inside specific or all containers.
• Snapshots & Backups: Easily snapshot and restore containers.
• Open Source (BSD 3-Clause License): Free to use and modify.
• Disk Quotas: Limit disk space usage per container.
• Stackable Templates: Reuse configurations by stacking templates.
• Active Development: Ongoing improvements and new features.

Supported Platforms

Bastille runs on any system where FreeBSD is supported, including:

• Servers
• Raspberry Pi
• Cloud Providers

Installing Bastille

Bastille is available through the FreeBSD ports and package system. You can install it using:

Using pkg

pkg install bastille

Using Ports

portsnap fetch auto
make -C /usr/ports/sysutils/bastille install clean

From Git (Bleeding Edge)

git clone https://github.com/bastillebsd/bastille.git
cd bastille
make install

Enable Bastille at Boot

sysrc bastille_enable=YES
sysrc bastille_rcorder=YES

Upgrading Bastille

If upgrading from a previous version, merge new configurations into your existing bastille.conf:

cd /usr/local/etc/bastille
diff -u bastille.conf bastille.conf.sample

Update your configuration as needed before proceeding.

Basic Usage

Bastille provides a simple command structure:

bastille command TARGET [args]

Common Commands

• bastille create – Create a new container.
• bastille start – Start a container.
• bastille stop – Stop a running container.
• bastille list – List running containers.
• bastille console – Access a running container.
• bastille destroy – Remove a container.

Setting Up Bastille

To configure networking, firewall, and storage, use:

bastille setup

For custom setups, you can specify options like bastille setup zfs or bastille setup vnet.

Note: If enabling the PF firewall, manually start it using service pf start after running bastille setup.

Example: Creating and Managing a Container

Step 1: Create a Container

bastille create alcatraz 14.0-RELEASE 10.17.89.10/24

Step 2: Start the Container

bastille start alcatraz

Output:

[alcatraz]:
alcatraz: created

Step 3: Access the Container

bastille console alcatraz

Output:

FreeBSD 14.0-RELEASE GENERIC
Welcome to FreeBSD!

Step 4: Check Running Processes

ps -auxw

Example Output:

USER   PID %CPU %MEM  VSZ  RSS TT  STAT STARTED    TIME COMMAND
root 83222  0.0  0.0 6412 2492  -  IsJ  02:21   0:00.00 /usr/sbin/syslogd -ss
root 88531  0.0  0.0 6464 2508  -  SsJ  02:21   0:00.01 /usr/sbin/cron -s

Conclusion

Bastille provides an efficient and secure way to manage FreeBSD containers. With powerful automation, security features, and ease of use, it is an excellent tool for developers and system administrators alike. If you’re running FreeBSD and need a container solution, give Bastille a try!

For more information, check out the official Bastille Documentation.

The post Automating FreeBSD Container Management with Bastille appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

HamClock is a powerful tool designed for amateur radio operators, providing real-time propagation data, satellite tracking, and more. This guide will walk you through installing HamClock on various UNIX-like systems, including Raspberry Pi, macOS, Debian, Ubuntu, FreeBSD, and others. Whether you’re using HamClock for monitoring solar conditions, DX cluster spots, or tracking satellites, this step-by-step tutorial will help you get started.

Step 1: Install Required Dependencies

Before installing HamClock, ensure your system has the necessary dependencies installed. These dependencies vary by operating system:

For Raspberry Pi and Debian-based Systems:

sudo apt-get update
sudo apt-get -y install curl make g++ libx11-dev libgpiod-dev xdg-utils

For Ubuntu:

sudo apt install curl make g++ xorg-dev xdg-utils

For macOS:

First, install XQuartz and Xcode. Then, open “More developer tools” and install the command line tools. On macOS Sequoia, you may need to run:

xcode-select --install

For FreeBSD:

sudo pkg install gcc xorg gmake curl

Then, use gmake instead of make.

For NetBSD:

First, install pkgin, then run:

sudo pkgin install gmake curl

Use gmake instead of make.

For RedHat or Fedora:

sudo yum install gcc-c++ libX11-devel xdg-utils

For Alpine Linux:

setup-desktop
apk add g++ libx11-dev curl linux-headers

Step 2: Install HamClock

Once the dependencies are installed, proceed with downloading and installing HamClock. There are two methods depending on your operating system.

For Raspberry Pi (Automated Install):

cd
curl -O https://www.clearskyinstitute.com/ham/HamClock/install-hc-rpi
chmod u+x install-hc-rpi
./install-hc-rpi

Follow the prompts and answer y or n as needed. This script will automate the installation for you.

For Other UNIX-like Systems (Manual Install):

cd
rm -fr ESPHamClock
curl -O https://www.clearskyinstitute.com/ham/HamClock/ESPHamClock.zip
unzip ESPHamClock.zip
cd ESPHamClock
make -j 4 hamclock-800x480
sudo make install

This will install HamClock with a resolution of 800×480 pixels. If you need a different resolution, refer to Step 4.

Step 3: Run HamClock

After installation, you can start HamClock with the following command:

hamclock &

If everything is installed correctly, HamClock should open in a window displaying solar data, propagation info, and maps.

If you did not install a desktop icon, you can always launch HamClock from the terminal using the command above.

Step 4: Customize HamClock

HamClock supports different screen sizes. If you want to change the resolution, use the following commands:

cd ~/ESPHamClock
make clean
make -j 4 hamclock-2400x1440
sudo make install

Replace 2400x1440 with the desired resolution:

• hamclock-1600x960
• hamclock-2400x1440
• hamclock-3200x1920

If you want HamClock to fill the screen completely, navigate to Page 5 in the Setup menu and enable the full-screen option.

Step 5: Auto-start HamClock on Boot

To ensure HamClock starts automatically on system boot, you can create an autostart entry.

For XDG-compliant systems:

cd ~/ESPHamClock
mkdir -p ~/.config/autostart
cp hamclock.desktop ~/.config/autostart

For macOS (Create a Clickable App):

If you’re using macOS, you can create a clickable app on your Desktop:

cd ~/ESPHamClock
HCDIR=~/Desktop/HamClock.app
mkdir -p $HCDIR
echo '#!/bin/bash' > $HCDIR/HamClock
echo '/usr/local/bin/hamclock &' >> $HCDIR/HamClock
chmod u+x $HCDIR/HamClock

To assign a proper icon, follow these steps:

1. Open hamclock.png with Preview.
2. Click on the image.
3. Press ⌘-A to select the image, then ⌘-C to copy.
4. Right-click the new HamClock.app Desktop item and select Get Info.
5. Click the existing default icon in the top left corner.
6. Press ⌘-V to paste the new icon.

Conclusion

By following these steps, you’ll have HamClock running seamlessly for amateur radio use, helping you track propagation, monitor DX cluster spots, and track satellites. Whether you’re using a Raspberry Pi, macOS, or a UNIX-like system, HamClock is a great addition to any ham radio station. For more info, visit https://www.clearskyinstitute.com/ham/HamClock/

Enjoy using HamClock and 73!

The post Installing HamClock for Amateur Radio Use appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

What is Meshtastic?

Meshtastic is an open-source, long-range, low-power communication system designed for off-grid messaging and location sharing using LoRa (Long Range) radios. It is a highly versatile and cost-effective alternative to traditional communication methods, enabling users to stay connected even in remote areas without cellular or internet coverage.

The system relies on small, low-power LoRa devices that form a mesh network, allowing messages to be relayed from node to node. This makes it an excellent tool for outdoor enthusiasts, emergency preparedness, community networking, and remote area deployments. Meshtastic works through dedicated hardware devices or DIY configurations using LoRa modules like the Heltec, TTGO, and RAK devices. The communication is facilitated through the Meshtastic app, available for both Android and iOS.

Introducing https://meshtastic.hamradio.my – Live Meshtastic Map

Meshtastic.hamradio.my is a live Meshtastic node map hosted inside a container on a Raspberry Pi, providing a lightweight and efficient mapping solution for Meshtastic nodes. This server is based in Malaysia, ensuring low-latency communication for users in the region.

The map provides real-time tracking of Meshtastic nodes connected via MQTT, displaying their locations and status in an easy-to-view format. Whether you’re setting up a local Meshtastic network for emergency response, outdoor adventures, or simply experimenting with off-grid communications, Meshtastic.hamradio.my helps you visualize node connections and monitor network activity.

This map is based on the open-source Meshtastic Map project, which provides a web-based visualization of Meshtastic nodes using MQTT data.

How Does the Meshtastic Map Work?

The Meshtastic Map operates by collecting data from nodes that are configured to report their locations via an MQTT (Message Queuing Telemetry Transport) broker. This lightweight messaging protocol is ideal for IoT and low-power devices. The collected data is then displayed on a web-based live map, giving users real-time insights into their Meshtastic network.

Setting Up Your Node for the Live Map

To uplink your Meshtastic node to this live map, follow these simple steps:

1. Install the Meshtastic App:
   • Download and install the Meshtastic app from the Google Play Store or Apple App Store.
2. Configure Your Device:
   • Power on your LoRa device running Meshtastic firmware.
   • Pair it with the Meshtastic app via Bluetooth or USB.
3. Enable MQTT and Set the Broker:
   • Open the Meshtastic app.
   • Navigate to Settings > MQTT Configuration.
   • Enable MQTT support.
   • Set the MQTT broker address to: mqtt.hamradio.my
   • Username: hamradio.my
   • Password: hamradio.my
4. Set OK to MQTT:
   • In the Meshtastic app, after configuring the broker, ensure that the MQTT status shows OK.
   • If it does not, double-check the broker address and save the settings again.
5. Save and Restart:
   • Save the configuration and restart your device.
   • Your node should now start reporting its location and appear on the live map at Meshtastic.hamradio.my.

Features of Meshtastic.hamradio.my

• Real-Time Node Tracking – View active Meshtastic nodes on the map as they transmit their locations.
• Lightweight MQTT-Based System – Optimized for low bandwidth and power consumption.
• Off-Grid Connectivity – Perfect for outdoor adventures, emergency response teams, and remote communities.
• Low-Latency Performance – Hosted in Malaysia to provide quick response times for local users.

Why Use Meshtastic for Off-Grid Communications?

Meshtastic is a game-changer for off-grid communications due to its flexibility, affordability, and ease of deployment. Some key benefits include:

• No Cellular or Internet Needed – Ideal for remote areas where traditional networks are unavailable.
• Extends Communication Range – LoRa radios can transmit several kilometers in open terrain.
• Mesh Networking – Messages can hop between multiple nodes, increasing the coverage area.
• Low Power Consumption – Devices can run on small batteries for days or even weeks.
• Community-Driven – Supported by an active open-source community continuously improving the project.

Get Started with Meshtastic Today!

If you’re interested in exploring Meshtastic and tracking your nodes on the live map, set up your device today and connect to mqtt.hamradio.my. Whether you’re using Meshtastic for adventure, emergency preparedness, or local networking, this map provides valuable insights into your network’s reach and performance.

Stay connected, stay prepared, and enhance your off-grid communication with Meshtastic!

The post Hamradio.my Meshtastic Map – Live Tracking for Off-Grid Communications appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.