Full working prototype

This guide builds on Stage 1, the bare minimum prototype. It is the complete Haven Home system a buyer would get:

• Everything in the bare minimum: shared offline library, push-to-talk at home, and family texting over the mesh.
• Whole-house Wi-Fi: a real router replaces the Pi’s built-in Wi-Fi, so more phones connect from farther away.
• Bigger library: a 1TB SSD holds Wikipedia with pictures, medical references, and map files phones can download from the hub.
• AI on the hub: any phone on the network can ask questions in a browser, even without an AI app installed.
• Rooftop relay: a solar Meshtastic node on the roof gives the family radios much more range.
• Four family radios instead of one.
• Weather alerts: the hub listens to NOAA Weather Radio and forwards alerts to every family radio.
• Battery backup: the hub keeps running through a power outage.
• Faraday bag and wall card for a spare radio and quick instructions.

What it looks like

The Pi hub plugs into the router by Ethernet and runs the library, AI, push-to-talk and weather alerts. The roof relay passes mesh messages between the hub radio and the family radios carried around town.

Blueprint 1: Wiring diagram

The roof relay powers itself from its panel and batteries, and the family radios charge on any USB charger with their magnetic cables.

Blueprint 2: Cage and caddy drawing

The cage is open on all four sides, so every port and the UPS power jack stay reachable without exact cutouts. It is sized from the X1202’s published 97.4 × 85 mm board (source) and the Pi 5’s 58 × 49 mm hole pattern.

Four values are placeholders you must measure before printing:

Blueprint 3: 3D-printable cage and caddy

The printed cage holds the Pi and UPS board stack, and the caddy keeps the SSD, weather receiver and a radio tidy beside it. The print files, haven_full_cage_base.stl, haven_full_cage_top.stl and haven_full_caddy.stl, and the editable source haven_full_hub.scad will be published here alongside the guide.

Hardware: 4 M2.5 × 6 mm screws for the board stack, 4 M3 × 8 mm screws to fix the top plate to the posts, and 4 self-adhesive rubber feet 10 mm across (the base has recesses for them).

Assembly order:

1. Measure your stacked X1202 and Pi 5, enter the values from the table above in the .scad file, and export new STLs with the free OpenSCAD program.
2. Print one cage base first and test-fit the board stack before printing the rest.
3. Screw the X1202 and Pi stack onto the standoffs, connect all cables, then screw on the top plate.
4. Set the caddy beside the cage on the side with the Pi’s USB ports, so the short cables reach.

Build steps

Plan on a weekend: one day for the hub and network, one for the radios, roof relay and weather alerts. If you built the bare minimum version, skip the steps marked (done in Stage 1) and keep its library, Mumble server and channel.

1. Assemble the hub

1. Fit the active cooler to the Pi 5.
2. Mount the X1202 UPS board under the Pi following the Geekworm wiki (wiki.geekworm.com/X1202). Insert the four 18650 cells, checking the polarity marks.
3. Put the stack in the metal case.
4. Plug power into the UPS board’s USB-C or DC jack, never the Pi’s own USB-C port. Geekworm warns against powering both.
5. Put the SSD in the USB enclosure and plug it into one of the Pi’s blue USB 3 ports.

2. Load and update the operating system (done in Stage 1)

Flash Raspberry Pi OS Lite (64-bit) to the microSD card with Raspberry Pi Imager, hostname haven, SSH enabled, home Wi-Fi set. Then:

sudo apt update && sudo apt full-upgrade -y
sudo reboot

3. Prepare the SSD

1. Find the drive name (usually sda) with lsblk.
2. Format it and mount it at /srv/haven (this erases the drive):

sudo mkfs.ext4 -L haven /dev/sda
sudo mkdir -p /srv/haven
echo 'LABEL=haven /srv/haven ext4 defaults,nofail 0 2' | sudo tee -a /etc/fstab
sudo mount -a
sudo chown -R $USER:$USER /srv/haven
mkdir -p /srv/haven/library /srv/haven/files /srv/haven/models

If you’re upgrading from the bare minimum build, move the library over with mv ~/library/*.zim /srv/haven/library/.

4. Load the library and map files

1. Install Kiwix if needed: sudo apt install -y kiwix-tools

2. From download.kiwix.org/zim/, download into /srv/haven/library with wget -c. With 1TB you can use the full English Wikipedia with pictures (wikipedia_en_all_maxi), plus WikiMed and Wikivoyage.

3. Download offline map files for your state into /srv/haven/files. OsmAnd .obf files can be imported from a phone’s downloads folder.

4. Point the Kiwix service at the SSD. Edit /etc/systemd/system/kiwix.service (create it as in the bare minimum guide if you don’t have it) so the start line reads:

   ExecStart=/bin/sh -c '/usr/bin/kiwix-serve --port=8080 /srv/haven/library/*.zim'

   sudo systemctl daemon-reload && sudo systemctl enable --now kiwix

5. Add a home page and file downloads

1. Install a small web server: sudo apt install -y nginx

2. Replace the default page so phones see one Haven home page:

   sudo nano /var/www/html/index.html

   <!doctype html><meta name="viewport" content="width=device-width">
   <h1>Haven</h1>
   <p><a href="http://haven.lan:8080">Library</a></p>
   <p><a href="http://haven.lan:8081">Ask Haven AI</a></p>
   <p><a href="/files/">Map and file downloads</a></p>

3. Serve the downloads folder. In /etc/nginx/sites-available/default, inside the server { } block, add:

   location /files/ { alias /srv/haven/files/; autoindex on; }

   sudo systemctl reload nginx

6. Install the walkie-talkie server (done in Stage 1)

sudo apt install -y mumble-server
sudo dpkg-reconfigure mumble-server

7. Install AI on the hub

This runs a small model with llama.cpp’s built-in chat page. Expect slower answers than on a phone; measure it in the tests.

sudo apt install -y git cmake build-essential
git clone https://github.com/ggml-org/llama.cpp ~/llama.cpp
cd ~/llama.cpp && cmake -B build && cmake --build build --config Release -j4

1. From Hugging Face, download a small instruction model in GGUF format, about 3B parameters at 4-bit (Q4_K_M), into /srv/haven/models. Read its license file before you use it.

2. Create /etc/systemd/system/haven-ai.service (replace yourusername and the model file name):

   [Unit]
   Description=Haven AI
   After=network.target
   
   [Service]
   User=yourusername
   ExecStart=/home/yourusername/llama.cpp/build/bin/llama-server -m /srv/haven/models/MODEL.gguf --host 0.0.0.0 --port 8081 -c 2048
   Restart=always
   
   [Install]
   WantedBy=multi-user.target

   sudo systemctl daemon-reload && sudo systemctl enable --now haven-ai

8. Set up the router

1. Power the Beryl AX and join its default Wi-Fi (the name and password are on its label). Open 192.168.8.1 and set an admin password.
2. Under Wireless, rename both bands to HavenHub and set your password.
3. Connect the Pi to one of the router’s Ethernet ports. Leave the WAN (internet) port empty.
4. Under Network, then LAN, reserve a fixed address for the Pi (for example 192.168.8.10) and add a local name entry haven.lan pointing to it, if your firmware version offers custom DNS entries. Otherwise, use the IP address everywhere this guide says haven.lan.
5. On the Pi, turn off its own hotspot if you made one: sudo nmcli connection delete Hotspot
6. For outages, plan to run the router from a USB-C power bank of 100Wh or less. Check the router’s power rating before relying on it.

9. Set up the radios

1. Charge all five T1000-E radios and the solar relay.

2. In the Meshtastic app, pair each radio in turn. On each, set Region: US and join the private channel (create it once, then share the QR code).

3. Set the hub radio and family radios to role CLIENT. Give each a name, such as Hub, Dad, Mom.

4. Plug the hub radio into a Pi USB port with its magnetic cable.

5. Install the Meshtastic command-line tool on the Pi and confirm it sees the radio:

   sudo apt install -y pipx && pipx ensurepath
   pipx install meshtastic
   meshtastic --info

10. Install the roof relay

1. Pair the Solar Node P1-Pro, set Region: US, join the same channel, and set its role to ROUTER, Meshtastic’s role for a fixed, well-placed relay.
2. Mount it on the bracket as high as you safely can, panel facing south, antenna vertical. Use its included antenna.

11. Set up weather alerts

1. Install the RTL-SDR Blog V4 drivers by following the V4 user guide at rtl-sdr.com (the V4 needs these instead of the stock drivers), then the decoder: sudo apt install -y multimon-ng

2. Plug the SDR into the Pi and set the dipole antenna up vertically, near a window or outside.

3. Look up the NOAA Weather Radio station that covers your area and note its frequency (between 162.400 and 162.550 MHz).

4. Create /home/yourusername/weather-alerts.sh (replace the frequency with yours):

   #!/bin/bash
   rtl_fm -f 162.550M -s 22050 - \
    | multimon-ng -t raw -a EAS - \
    | grep --line-buffered 'EAS:' \
    | while read -r line; do
        meshtastic --sendtext "WEATHER ALERT: ${line:0:180}"
      done

5. Make it executable (chmod +x ~/weather-alerts.sh) and run it as a service the same way as Kiwix, with ExecStart=/home/yourusername/weather-alerts.sh.

6. The alert arrives as raw alert codes. A decoder such as dsame3 can turn them into plain English later.

12. Finish the kit

1. Print and laminate the wall card: network name and password, http://haven.lan, the Mumble address, and the Meshtastic channel QR code.
2. Put a spare radio and a backup copy of the microSD card in the Faraday bag. Test the bag by trying to message the sealed radio.
3. On each phone: join HavenHub, bookmark http://haven.lan, add the Mumble server at haven.lan port 64738, and install the offline AI app as a backup.

Tests that prove it works

Run every test with your home internet unplugged, and record each result.

• Home page: five phones open http://haven.lan at once and load the library, AI page and file downloads.
• Wi-Fi coverage: walk the house and yard and mark where the library stops loading.
• Push-to-talk: three phones talk on Mumble from different rooms and the yard.
• Hub AI: ask three real questions from a phone browser. Record seconds to the first word and whether the answers are right.
• Mesh range: with the roof relay up, carry a family radio away from the house and note the farthest point messages still arrive. Repeat with the relay unplugged to see the difference.
• Location: confirm every family radio’s position shows on the Meshtastic map.
• Weather alerts: leave the alert service running through a NOAA weekly test broadcast and confirm the message reaches every radio.
• Power outage: flip the breaker or unplug the hub and router power. Record how long the hub runs on the UPS board and the router on the power bank.
• Restart: after power returns, confirm the Wi-Fi, library, Mumble, AI and alert services all come back on their own.
• Faraday bag: message the sealed spare radio and confirm nothing gets through, including after folding the bag 20 times.

Notes and cautions

• Radio rules: buy radios that are FCC-certified, as the T1000-E is. Use the relay’s included antenna; a different antenna can change a device’s certification.
• Batteries: the UPS cells, relay batteries and radios all contain lithium. Use protected cells from a reputable seller, ship them by ground only, follow UN 38.3 rules, and keep each pack under 100Wh.
• Voice range: push-to-talk works only within the router’s Wi-Fi. Long-distance contact is text and location over the mesh.
• Hub AI speed: a Pi runs a 3B model slowly. If the test answers are too slow, keep AI on the phones and drop the 8GB Pi for a 4GB one.
• Weather alerts: the script forwards raw alert codes. Treat it as an extra warning, never a replacement for official alerts.
• Content licensing: Wikipedia-family files and OpenStreetMap maps can be shared with attribution. Check each AI model’s license file before you use it.
• Roof work: use a stable ladder, have a second person present, and stay well away from power lines.