Turning Old Helium Miners into Meshtastic Tower Nodes

sudo apt update -y
sudo DEBIAN_FRONTEND=noninteractive apt-get -y \
  -o Dpkg::Options::="--force-confdef" \
  -o Dpkg::Options::="--force-confold" \
  dist-upgrade

echo 'deb http://download.opensuse.org/repositories/network:/Meshtastic:/beta/Debian_13/ /' \
  | sudo tee /etc/apt/sources.list.d/network:Meshtastic:beta.list
curl -fsSL https://download.opensuse.org/repositories/network:Meshtastic:beta/Debian_13/Release.key \
  | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/network_Meshtastic_beta.gpg > /dev/null

sudo apt update -y
sudo apt install -y meshtasticd i2c-tools pipx
pipx install "meshtastic[cli]"
pipx ensurepath

dtparam=spi=on
dtoverlay=spi0-0cs
dtparam=i2c_arm=on

sudo apt install -y avahi-daemon
sudo tee /etc/avahi/services/meshtastic.service > /dev/null <<'EOF'
<?xml version="1.0" standalone="no"?><!--*-nxml-*-->
<!DOCTYPE service-group SYSTEM "avahi-service.dtd">
<service-group>
    <name>Meshtastic</name>
    <service protocol="ipv4">
        <type>_meshtastic._tcp</type>
        <port>4403</port>
    </service>
</service-group>
EOF
sudo systemctl enable --now avahi-daemon
sudo hostnamectl set-hostname MYCALL-Node01
sudo systemctl restart avahi-daemon

sudo wget -O /etc/meshtasticd/config.d/NebraHat_2W.yaml \
  https://github.com/wehooper4/meshtastic-Hardware/raw/refs/heads/main/NebraHat/NebraHat_2W.yaml
sudo nano /etc/meshtasticd/config.d/NebraHat_2W.yaml
# Other hats:
#   NebraHat 1W:       .../NebraHat/NebraHat_1W.yaml
#   NebraHat Duo E22P: .../NebraHat/Duo/NebraHat_Duo_E22P.yaml
#   ZebraHat:          .../ZebraHAT/ZebraHat.yaml

sudo systemctl enable --now meshtasticd

meshtastic --host --set lora.region US
meshtastic --host --set-owner "My Mesh - Town - Tower"
meshtastic --host --set-owner-short "MESH"
meshtastic --host --export-config | grep "Key:"   # save these keys somewhere safe

sudo apt install -y gpsd gpsd-clients chrony socat

# Append to /boot/firmware/config.txt:
#   enable_uart=1
#   dtoverlay=uart1,txd1_pin=32,rxd1_pin=33,pin_func=7
sudo nano /boot/firmware/config.txt
sudo raspi-config nonint do_serial_hw 0     # enable the serial port
sudo raspi-config nonint do_serial_cons 1   # disable the serial console

# /etc/default/gpsd:      DEVICES="/dev/serial1"
# /etc/chrony/chrony.conf: refclock SHM 0 refid GPS precision 1e-1 offset 0.0 delay 0.2
sudo nano /etc/default/gpsd
sudo nano /etc/chrony/chrony.conf
sudo systemctl restart chrony
sudo reboot

sudo apt update
sudo apt install -y network-manager modemmanager gpsd gpsd-clients chrony socat
sudo systemctl enable --now NetworkManager ModemManager

nmcli device
mmcli -L        # look for .../Modem/0 [QUECTEL INCORPORATED] EG25; if it's Modem/1, use -m 1
sudo mmcli -m 0 --enable

# Registers without data. For data, add: gsm.apn <your_carrier_apn>
sudo nmcli connection add type gsm ifname "*" con-name mycell
sudo nmcli connection up mycell
sudo nmcli connection modify mycell connection.autoconnect yes

mmcli -m 0      # ports: cdc-wdm0 (qmi), ttyUSB0 (qcdm), ttyUSB1 (gps), ttyUSB2 (at), ...
sudo mmcli -m 0 --location-enable-gps-unmanaged
sudo mmcli -m 0 --location-set-enable-signal
sudo mmcli -m 0 --location-get
mmcli -m 0 --location-status

# Point gpsd at the (gps) port from above
sudo tee /etc/default/gpsd > /dev/null <<'EOF'
START_DAEMON="true"
GPSD_OPTIONS="-n"
DEVICES="/dev/ttyUSB1"
USBAUTO="false"
EOF
sudo systemctl enable --now gpsd

sudo tee /etc/systemd/system/meshtastic-pty.service > /dev/null <<'EOF'
[Unit]
Description=Meshtastic virtual PTY pair for GPS (socat)
After=network.target

[Service]
Type=simple
RuntimeDirectory=meshtastic
ExecStart=/usr/bin/env socat -d -d pty,raw,echo=0,link=/run/meshtastic/gps_in,mode=666 pty,raw,echo=0,link=/run/meshtastic/gps_feed,mode=666
Restart=always
RestartSec=2

[Install]
WantedBy=multi-user.target
EOF

sudo tee /etc/systemd/system/meshtastic-gpspipe.service > /dev/null <<'EOF'
[Unit]
Description=Feed NMEA from gpsd into Meshtastic PTY
Requires=meshtastic-pty.service gpsd.service
After=meshtastic-pty.service gpsd.service

[Service]
Type=simple
ExecStart=/bin/sh -lc 'while [ ! -c /run/meshtastic/gps_feed ]; do sleep 0.5; done; exec /usr/bin/env gpspipe -r > /run/meshtastic/gps_feed'
Restart=always
RestartSec=2

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now meshtastic-pty.service meshtastic-gpspipe.service
systemctl --no-pager status meshtastic-pty meshtastic-gpspipe

ls -l /run/meshtastic                        # gps_feed and gps_in should exist
sudo timeout 3 cat /run/meshtastic/gps_in    # should print NMEA sentences
journalctl -u meshtastic-pty -b --no-pager   # should show no errors

GPS:
  SerialPath: /run/meshtastic/gps_in

#!/bin/bash
# Ensure ModemManager location features are on for all detected modems.
# Requires: mmcli, flock. Run as root (cron/systemd).

set -euo pipefail

LOG_FILE="/var/log/mm-location-monitor.log"
MMCLI="${MMCLI:-/usr/bin/mmcli}"
DATE="/bin/date"
FLOCK="/usr/bin/flock"
LOCKFILE="/var/lock/mm-location-monitor.lock"

log() {
  echo "$($DATE '+%Y-%m-%d %H:%M:%S')  $*" | tee -a "$LOG_FILE"
}

list_modem_ids() {
  # Output: one modem ID per line (e.g., 0, 1, 2 ...), or nothing if none exist
  # mmcli -L example line:
  # /org/freedesktop/ModemManager1/Modem/1 [QUALCOMM INCORPORATED] QUECTEL Mobile Broadband Module
  "$MMCLI" -L 2>/dev/null | sed -En 's#.*/Modem/([0-9]+).*#\1#p'
}

check_and_fix_modem() {
  local MID="$1"

  # Verify the modem exists
  if ! "$MMCLI" -m "$MID" >/dev/null 2>&1; then
    log "modem $MID: not present; skipping"
    return 0
  fi

  # Read location status
  local STATUS
  if ! STATUS="$("$MMCLI" -m "$MID" --location-status 2>&1)"; then
    log "modem $MID: failed to read location-status"
    return 1
  fi

  # Quick capability check; if modem doesn't support gps-unmanaged, don't spam errors
  local CAP_LINE
  CAP_LINE="$(echo "$STATUS" | grep -E '^\s*\|\s*capabilities:' || true)"
  if ! echo "$CAP_LINE" | grep -q 'gps-unmanaged'; then
    log "modem $MID: no gps-unmanaged capability; skipping gps enable"
  fi

  # Parse "enabled" and "signals"
  local ENABLED_LINE SIGNALS_LINE
  ENABLED_LINE="$(echo "$STATUS"  | grep -E '^\s*\|\s*enabled:'  || true)"
  SIGNALS_LINE="$(echo "$STATUS"  | grep -E '^\s*\|\s*signals:'  || true)"

  local HAS_GPS_UNMANAGED="no" HAS_SIGNALS="no"
  if echo "$ENABLED_LINE" | grep -q 'gps-unmanaged'; then HAS_GPS_UNMANAGED="yes"; fi
  if echo "$SIGNALS_LINE" | grep -q 'yes'; then HAS_SIGNALS="yes"; fi

  local changed="no"

  # Enable gps-unmanaged if missing and supported
  if [ "$HAS_GPS_UNMANAGED" != "yes" ] && echo "$CAP_LINE" | grep -q 'gps-unmanaged'; then
    if "$MMCLI" -m "$MID" --location-enable-gps-unmanaged >/dev/null 2>&1; then
      log "modem $MID: enabled gps-unmanaged"
      changed="yes"
    else
      log "modem $MID: FAILED to enable gps-unmanaged"
    fi
  fi

  # Enable signals if missing (try both flags for compatibility)
  if [ "$HAS_SIGNALS" != "yes" ]; then
    if "$MMCLI" -m "$MID" --location-enable-signals >/dev/null 2>&1; then
      log "modem $MID: enabled signals"
      changed="yes"
    elif "$MMCLI" -m "$MID" --location-set-enable-signal >/dev/null 2>&1; then
      log "modem $MID: enabled signals (compat flag)"
      changed="yes"
    else
      log "modem $MID: FAILED to enable signals"
    fi
  fi

  # Dump refreshed status if anything changed
  if [ "$changed" = "yes" ]; then
    "$MMCLI" -m "$MID" --location-status | sed 's/^/modem '"$MID"': /' | tee -a "$LOG_FILE" >/dev/null
  else
    log "modem $MID: already OK (gps-unmanaged + signals)"
  fi
}

_main_run() {
  local any=0
  while IFS= read -r MID; do
    any=1
    check_and_fix_modem "$MID"
  done < <(list_modem_ids)

  if [ "$any" -eq 0 ]; then
    log "no modems detected by ModemManager"
  fi
}

main() {
  # Serialize concurrent runs; exits quietly if another run holds the lock
  exec "$FLOCK" -n "$LOCKFILE" "$0" _run
}

if [ "${1:-}" = "_run" ]; then
  _main_run
else
  main
fi

sudo chmod 755 /usr/local/bin/check_mm_location.sh
sudo touch /var/log/mm-location-monitor.log
sudo chown root:adm /var/log/mm-location-monitor.log
sudo crontab -e
# 0 * * * * /usr/local/bin/check_mm_location.sh

sudo systemctl enable --now ModemManager NetworkManager
sudo mmcli -m any --enable
sudo nmcli connection add type gsm ifname "*" con-name LTE \
    apn m2mglobal connection.autoconnect yes ipv4.method auto
sudo nmcli connection modify LTE gsm.network-id 310260
sudo reboot
# a couple of minutes later:
ip route show
ip addr show wwan0

sudo nmcli connection add type wifi ifname wlan0 con-name mywifi ssid "SSID_NAME"
sudo nmcli connection modify mywifi wifi-sec.key-mgmt wpa-psk
sudo nmcli connection modify mywifi wifi-sec.psk "YOUR_PASSWORD"
sudo nmcli connection modify mywifi connection.autoconnect yes

#!/bin/bash
# Simple AP setup script for Debian
# Run as root

### CONFIGURATION ###
AP_SSID="MyAccessPoint"
AP_PASSWORD="SuperSecret123"
WLAN_IF="wlan0"
AP_IP="192.168.50.1"
DHCP_RANGE_START="192.168.50.10"
DHCP_RANGE_END="192.168.50.200"
UPLINK_IF="eth0"   # or wwan0 if you want to NAT to LTE
####################

set -e

echo "[*] Installing required packages..."
apt -o Acquire::ForceIPv4=true update
apt -o Acquire::ForceIPv4=true install -y hostapd dnsmasq iptables-persistent ifupdown

echo "[*] Stopping services until configured..."
systemctl stop hostapd || true
systemctl stop dnsmasq || true

echo "[*] Configuring static IP on $WLAN_IF..."
cat >/etc/network/interfaces.d/$WLAN_IF <<EOF
auto $WLAN_IF
iface $WLAN_IF inet static
    address $AP_IP
    netmask 255.255.255.0
EOF
ifdown $WLAN_IF || true
ifup $WLAN_IF

echo "[*] Configuring dnsmasq..."
mv /etc/dnsmasq.conf /etc/dnsmasq.conf.orig.$(date +%s) || true
cat >/etc/dnsmasq.conf <<EOF
interface=$WLAN_IF
dhcp-range=$DHCP_RANGE_START,$DHCP_RANGE_END,255.255.255.0,24h
EOF

echo "[*] Configuring hostapd..."
cat >/etc/hostapd/hostapd.conf <<EOF
interface=$WLAN_IF
driver=nl80211
ssid=$AP_SSID
hw_mode=g
channel=6
wmm_enabled=1
auth_algs=1
ignore_broadcast_ssid=0
wpa=2
wpa_passphrase=$AP_PASSWORD
wpa_key_mgmt=WPA-PSK
rsn_pairwise=CCMP
EOF

# Point hostapd to config
sed -i "s|^#DAEMON_CONF=.*|DAEMON_CONF=\"/etc/hostapd/hostapd.conf\"|" /etc/default/hostapd

echo "[*] Enabling IP forwarding..."
sed -i 's/^#\?net.ipv4.ip_forward.*/net.ipv4.ip_forward=1/' /etc/sysctl.conf
sysctl -p

echo "[*] Setting up NAT to $UPLINK_IF..."
iptables -t nat -A POSTROUTING -o $UPLINK_IF -j MASQUERADE
iptables -A FORWARD -i $UPLINK_IF -o $WLAN_IF -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i $WLAN_IF -o $UPLINK_IF -j ACCEPT
netfilter-persistent save

echo "[*] Enabling services..."
systemctl unmask hostapd
systemctl enable hostapd
systemctl enable dnsmasq
systemctl restart hostapd
systemctl restart dnsmasq

echo "[+] Access Point setup complete!"
echo "    SSID: $AP_SSID"
echo "    Password: $AP_PASSWORD"
echo "    Interface: $WLAN_IF ($AP_IP)"

curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

sudo tee /usr/local/bin/check_meshtasticd.sh > /dev/null <<'EOF'
#!/bin/bash
SERVICE="meshtasticd"
if ! pgrep -x "$SERVICE" > /dev/null; then
    echo "$(date): $SERVICE not running, restarting..." >> /var/log/meshtasticd_monitor.log
    systemctl restart $SERVICE
fi
EOF
sudo chmod +x /usr/local/bin/check_meshtasticd.sh
sudo crontab -e
# 0 * * * * /usr/local/bin/check_meshtasticd.sh
# 0 1 * * 1 /sbin/reboot

sudo apt update
sudo apt install -y rtl-sdr rtl-433 soapyremote-server
lsusb | grep RTL2838   # ID 0bda:2838 Realtek Semiconductor Corp. RTL2838 DVB-T

sudo tee /etc/udev/rules.d/20-rtl-sdr.rules > /dev/null <<'EOF'
# NooElec NESDR / RTL2832U SDR dongles
SUBSYSTEM=="usb", ATTRS{idVendor}=="0bda", ATTRS{idProduct}=="2838", MODE="0666", GROUP="plugdev"
EOF
sudo udevadm control --reload-rules
sudo udevadm trigger
sudo usermod -aG plugdev $USER

rtl_test -t                                           # test the SDR
rtl_sdr -s 2048000 -f 100e6 -n 2048000 /tmp/fm.iq     # test capture
rtl_tcp -a 0.0.0.0 -p 1234                            # serve it (or: soapyremote-server)

# Optional: blacklist the DVB-T drivers so SDR tools can claim the dongle directly
echo "blacklist dvb_usb_rtl28xxu
blacklist rtl2832
blacklist rtl2830" | sudo tee /etc/modprobe.d/blacklist-rtlsdr.conf
sudo update-initramfs -u
sudo reboot
lsmod | grep rtl     # should not list dvb_usb_rtl28xxu, rtl2832 or rtl2830

#!/usr/bin/env bash
set -euo pipefail

# --- Instances ---
ZEBRA_NAME="zebra"
USB_NAME="usb"

ZEBRA_PORT="4403"
USB_PORT="4404"

BASE_CFG="/etc/meshtasticd/config.yaml"

ZEBRA_DIR="/etc/meshtasticd/${ZEBRA_NAME}"
USB_DIR="/etc/meshtasticd/${USB_NAME}"

ZEBRA_CFG="${ZEBRA_DIR}/config.yaml"
USB_CFG="${USB_DIR}/config.yaml"

ZEBRA_CFGD="${ZEBRA_DIR}/config.d"
USB_CFGD="${USB_DIR}/config.d"

ZEBRA_YAML="${ZEBRA_CFGD}/ZebraHat.yaml"
ZEBRA_YAML_URL="https://raw.githubusercontent.com/wehooper4/Meshtastic-Hardware/refs/heads/main/ZebraHAT/ZebraHat.yaml"

ZEBRA_FSDIR="/var/lib/meshtasticd-${ZEBRA_NAME}"
USB_FSDIR="/var/lib/meshtasticd-${USB_NAME}"

ZEBRA_UNIT="/etc/systemd/system/meshtasticd-${ZEBRA_NAME}.service"
USB_UNIT="/etc/systemd/system/meshtasticd-${USB_NAME}.service"

MESHTASTICD_BIN="/usr/bin/meshtasticd"

# --- Helper: generate random MAC like AA:BB:CC:DD:EE:FF (random last 3 bytes) ---
rand_mac() {
  local r
  r="$(openssl rand -hex 3)"              # 6 hex chars
  # Format: AA:BB:CC:xx:yy:zz
  printf "AA:BB:CC:%s:%s:%s\n" "${r:0:2}" "${r:2:2}" "${r:4:2}"
}

# --- Helper: patch config.yaml (YAML indentation safe) ---
patch_config() {
  local cfg="$1"
  local cfgdir="$2"
  local mac="$3"

  # 1) Point ConfigDirectory at instance-specific config.d (keep YAML indentation)
  #    Replace any existing ConfigDirectory line (commented or not).
  if grep -qE '^[[:space:]]*ConfigDirectory:' "$cfg"; then
    sed -i -E "s|^[[:space:]]*ConfigDirectory:[[:space:]]*.*$|  ConfigDirectory: ${cfgdir}/|" "$cfg"
  else
    # Insert after "General:" line
    awk -v cfgdir="${cfgdir}" '
      {print}
      /^General:[[:space:]]*$/ {print "  ConfigDirectory: " cfgdir "/"}
    ' "$cfg" > "${cfg}.tmp" && mv "${cfg}.tmp" "$cfg"
  fi

  # 2) Comment out MACAddressSource: eth0 with YAML-safe indentation:
  #    "  MACAddressSource: eth0"  -> "  # MACAddressSource: eth0"
  #    If it's already commented, leave it alone.
  sed -i -E 's/^([[:space:]]*)MACAddressSource:[[:space:]]*eth0/\1# MACAddressSource: eth0/' "$cfg"

  # 3) Ensure MACAddress is set with EXACTLY two leading spaces:
  #    Replace existing commented/uncommented MACAddress line, anywhere.
  if grep -qE '^[[:space:]]*#?[[:space:]]*MACAddress:[[:space:]]*' "$cfg"; then
    # Normalize to exactly "  MACAddress: <mac>"
    sed -i -E "s|^[[:space:]]*#?[[:space:]]*MACAddress:[[:space:]]*.*$|  MACAddress: ${mac}|" "$cfg"
  else
    # Insert after "General:" line
    awk -v mac="${mac}" '
      {print}
      /^General:[[:space:]]*$/ {print "  MACAddress: " mac}
    ' "$cfg" > "${cfg}.tmp" && mv "${cfg}.tmp" "$cfg"
  fi
}

# --- Preconditions ---
if [[ $EUID -ne 0 ]]; then
  echo "ERROR: Run as root (sudo)."
  exit 1
fi

if [[ ! -f "$BASE_CFG" ]]; then
  echo "ERROR: Base config not found at $BASE_CFG"
  exit 1
fi

if [[ ! -x "$MESHTASTICD_BIN" ]]; then
  echo "ERROR: meshtasticd not found/executable at $MESHTASTICD_BIN"
  exit 1
fi

# --- STOP/DISABLE ORIGINAL SINGLE-INSTANCE SERVICE (no prompt) ---
if systemctl list-unit-files | grep -qE '^meshtasticd\.service'; then
  echo "Stopping/disabling original meshtasticd.service ..."
  systemctl stop meshtasticd.service || true
  systemctl disable meshtasticd.service || true
  systemctl mask meshtasticd.service || true
fi

# --- Create directories ---
mkdir -p "$ZEBRA_CFGD" "$USB_CFGD"
mkdir -p "$ZEBRA_FSDIR" "$USB_FSDIR"

# --- Copy base config.yaml into each instance directory ---
cp -f "$BASE_CFG" "$ZEBRA_CFG"
cp -f "$BASE_CFG" "$USB_CFG"

# --- Download ZebraHat.yaml into zebra instance config.d ---
wget -q -O "$ZEBRA_YAML" "$ZEBRA_YAML_URL"

# --- Patch both instance configs ---
ZEBRA_MAC="$(rand_mac)"
USB_MAC="$(rand_mac)"

patch_config "$ZEBRA_CFG" "$ZEBRA_CFGD" "$ZEBRA_MAC"
patch_config "$USB_CFG" "$USB_CFGD" "$USB_MAC"

# --- Determine whether meshtasticd user exists ---
USE_USERGROUP="yes"
if ! id meshtasticd >/dev/null 2>&1; then
  USE_USERGROUP="no"
  echo "WARN: user 'meshtasticd' not found; unit files will run as root."
fi

# --- Write unit files (multi-instance pattern: --port, --config, --fsdir) ---
cat > "$ZEBRA_UNIT" <<EOF
[Unit]
Description=Meshtastic Native Daemon (${ZEBRA_NAME})
After=network-online.target
StartLimitInterval=200
StartLimitBurst=5

[Service]
AmbientCapabilities=CAP_NET_BIND_SERVICE
Type=simple
EOF

if [[ "$USE_USERGROUP" == "yes" ]]; then
cat >> "$ZEBRA_UNIT" <<EOF
User=meshtasticd
Group=meshtasticd
EOF
fi

cat >> "$ZEBRA_UNIT" <<EOF
ExecStart=${MESHTASTICD_BIN} --port ${ZEBRA_PORT} --config ${ZEBRA_CFG} --fsdir ${ZEBRA_FSDIR}
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target
EOF

cat > "$USB_UNIT" <<EOF
[Unit]
Description=Meshtastic Native Daemon (${USB_NAME})
After=network-online.target
StartLimitInterval=200
StartLimitBurst=5

[Service]
AmbientCapabilities=CAP_NET_BIND_SERVICE
Type=simple
EOF

if [[ "$USE_USERGROUP" == "yes" ]]; then
cat >> "$USB_UNIT" <<EOF
User=meshtasticd
Group=meshtasticd
EOF
fi

cat >> "$USB_UNIT" <<EOF
ExecStart=${MESHTASTICD_BIN} --port ${USB_PORT} --config ${USB_CFG} --fsdir ${USB_FSDIR}
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target
EOF

# --- Permissions (fix /var/lib/meshtasticd-zebra and friends) ---
# Ensure sane modes regardless of whether the user/group exists.
chmod 0755 "$ZEBRA_DIR" "$USB_DIR" "$ZEBRA_CFGD" "$USB_CFGD" || true
chmod 0644 "$ZEBRA_CFG" "$USB_CFG" "$ZEBRA_YAML" || true
chmod 0750 "$ZEBRA_FSDIR" "$USB_FSDIR" || true

if [[ "$USE_USERGROUP" == "yes" ]]; then
  chown -R meshtasticd:meshtasticd "$ZEBRA_DIR" "$USB_DIR" || true
  chown -R meshtasticd:meshtasticd "$ZEBRA_FSDIR" "$USB_FSDIR" || true
fi

# --- Enable and start new instances ---
systemctl daemon-reload
systemctl enable --now "meshtasticd-${ZEBRA_NAME}.service"
systemctl enable --now "meshtasticd-${USB_NAME}.service"

echo
echo "Created and started:"
echo "  meshtasticd-${ZEBRA_NAME}.service (port ${ZEBRA_PORT})"
echo "  meshtasticd-${USB_NAME}.service   (port ${USB_PORT})"
echo
echo "Configs:"
echo "  $ZEBRA_CFG  (MACAddress: ${ZEBRA_MAC}, ConfigDirectory: ${ZEBRA_CFGD}/)"
echo "  $USB_CFG    (MACAddress: ${USB_MAC},   ConfigDirectory: ${USB_CFGD}/)"
echo
echo "ZebraHat.yaml:"
echo "  $ZEBRA_YAML"
echo
echo "Check status/logs:"
echo "  systemctl status meshtasticd-${ZEBRA_NAME}.service"
echo "  systemctl status meshtasticd-${USB_NAME}.service"
echo "  journalctl -u meshtasticd-${ZEBRA_NAME}.service -f"
echo "  journalctl -u meshtasticd-${USB_NAME}.service -f"

meshtastic --host localhost:4403 --set lora.region US
meshtastic --host localhost:4403 --set-owner "My Mesh - Radio 1"
meshtastic --host localhost:4403 --set-owner-short "MSH1"
meshtastic --host localhost:4403 --set network.enable_protocols 1

meshtastic --host localhost:4404 --set lora.region US
meshtastic --host localhost:4404 --set-owner "My Mesh - Radio 2"
meshtastic --host localhost:4404 --set-owner-short "MSH2"
meshtastic --host localhost:4404 --set network.enable_protocols 1

sudo systemctl restart meshtasticd-zebra meshtasticd-usb

sudo chown -R meshtasticd:meshtasticd /var/lib/meshtasticd-zebra /var/lib/meshtasticd-usb
sudo chmod 750 /var/lib/meshtasticd-zebra /var/lib/meshtasticd-usb
sudo find /var/lib/meshtasticd-zebra /var/lib/meshtasticd-usb -type d -exec chmod 750 {} \;