rtl_433/<host>/devices/Fineoffset-WH25/170/temperature_C  => 24.3
rtl_433/<host>/devices/Fineoffset-WH25/170/humidity       => 46
rtl_433/<host>/devices/Fineoffset-WH25/170/pressure_hPa   => 1010.1

I wanted those three numbers in the same weewx database as the outdoor data, so the reports show inTemp, inHumidity and station pressure next to everything else.

The catch: weewx loads exactly one station driver. station_type names it, and that driver’s genLoopPackets() is the only source of loop packets. The interceptor is already that driver.

MetaDriver

Tom Keffer, who writes weewx, published weewx-metadriver. It is a driver whose job is to run other drivers. You list the station types you want, it loads each one with the normal loader() call, runs each on its own thread, and merges their loop packets into one queue that the engine reads from. The first driver in the list is the primary: its archive records and clock functions are the ones weewx uses. The others only contribute loop packets. Every packet gets a source key naming the child it came from.

Installation is the usual extension install:

~/weewx-venv/bin/python ~/weewx/src/weectl.py extension install --yes \
  https://github.com/tkeffer/weewx-metadriver/archive/refs/heads/master.zip

I skipped the suggested weectl station reconfigure and edited weewx.conf by hand, so nothing else in the file moved:

[Station]
    station_type = MetaDriver

[MetaDriver]
    # The first entry is the primary station.
    station_types = Interceptor, wxMesh
    driver = user.metadriver

The [Interceptor] stanza stays exactly as it was. record_generation = software in [StdArchive] stays too. That’s what makes this work: with software record generation, weewx builds each archive record by accumulating every loop packet from the interval, whichever child it came from. The WH25 values and the Vevor values land in the same record.

Two things I checked before trusting it. The string source key goes through the accumulator like any other field, and weewx 5.5’s scalar accumulator quietly converts non-numeric values to None rather than crashing. And [StdConvert] target_unit = US converts each loop packet before it is accumulated, so one child sending metric and the other sending US units is fine.

An MQTT driver from 2016

For the MQTT side I used weewxMQTT, a small driver called wxMesh that subscribes to a topic and turns messages into loop packets. It is from the weewx 3 and 4 era and hasn’t been updated, which showed up in several ways:

• The installer doesn’t run. install.py imports setup, which weewx 5 no longer provides, and its config block isn’t valid Python. So I copied bin/user/wxMesh.py into ~/weewx-data/bin/user/ by hand and wrote the stanza myself.
• paho-mqtt 2.x rejects the old constructor. pip install paho-mqtt gives you 2.1.0 today, and mqtt.Client(client_id=...) raises ValueError: Unsupported callback API version unless you pass CallbackAPIVersion.VERSION1 first.
• A broker outage at start-up kills it for good. The driver called client.connect() in __init__, which raises if the broker is down. MetaDriver logs a failed secondary child and drops it. It never retries.
• No dateTime unless the message carries one. weewx services index packets by dateTime; a packet without it crashes them.
• Wrong message format for rtl_433. The driver wants one message with a payload like temp:24.3,humidity:46. rtl_433 publishes a bare number per topic. Feeding it 24.3 makes datum.split(":") fail to unpack, which ends the generator, which MetaDriver treats as a dead child.

The last point is the interesting one. In the original design the payload’s keys name the observations. With rtl_433 the topic is the key.

The rewrite

I kept the driver’s shape and rewrote the internals. The upstream file stays next to it as wxMesh.py.orig. The parts that matter:

kwargs = dict(client_id=self.client_id, clean_session=False,
              protocol=mqtt.MQTTv311, transport="tcp")
if hasattr(mqtt, 'CallbackAPIVersion'):      # paho-mqtt >= 2.0
    self.client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION1, **kwargs)
else:
    self.client = mqtt.Client(**kwargs)

self.client.reconnect_delay_set(min_delay=1, max_delay=60)
self.client.connect_async(self.host, self.port, 60)   # never raises here
self.client.loop_start()

connect_async() hands the connection to paho’s network thread, which retries with back-off if the broker isn’t there. Subscribing happens in on_connect, so a reconnect re-subscribes too.

Each message is parsed one of two ways. If the payload contains a colon it is the classic key:value,key:value form. Otherwise the topic is the key and the payload is the value:

def _parse(self, topic, payload):
    data = {}
    if ':' in payload:
        for datum in payload.split(","):
            key, sep, value = datum.partition(":")
            if sep:
                data[key.strip()] = value.strip()
    else:
        data[topic] = payload
    return data

Turning that into a packet uses the label_map from the config. A key is kept if the map knows it, or if it already is a weewx observation name. Anything else is dropped. That matters with a wildcard subscription, because rtl_433 also publishes battery_ok, mic, id and a time string under the same prefix, and none of those belong in a loop packet.

def _to_packet(self, data):
    packet = {'usUnits': self.units}
    for key, value in data.items():
        if key in self.label_map:
            name = self.label_map[key]
        elif key in weewx.units.obs_group_dict:
            name = key
        else:
            continue
        try:
            packet[name] = float(value)
        except ValueError:
            pass
    if not [k for k in packet if k not in ('usUnits', 'dateTime')]:
        return None
    ts = packet.get('dateTime')
    packet['dateTime'] = int(ts) if ts else int(time.time() + 0.5)
    return packet

A packet with only one field is completely normal for weewx. The accumulator takes whatever each packet has. So each rtl_433 message becomes its own tiny packet, and the archive record at the end of the interval has all three values.

The rest of the changes are small: a units option instead of a hard-coded unit system, a port option, the configured client id actually being used, topic accepting a list, and logging through weewx’s logger so the messages show up under journalctl -u weewx with the rest.

The stanza

[wxMesh]
    driver = user.wxMesh
    host = <broker-address>
    port = 1883
    username = <user>
    password = <password>
    client = weewx-pi3-1
    # Quote these. An unquoted # starts a comment in weewx.conf.
    topic = "rtl_433/<host>/devices/Fineoffset-WH25/170/#", "weewx/loop"
    units = METRIC          # rtl_433 sends degC and hPa
    poll_interval = 2
    [[label_map]]
        TIME = dateTime
        rtl_433/<host>/devices/Fineoffset-WH25/170/temperature_C = inTemp
        rtl_433/<host>/devices/Fineoffset-WH25/170/humidity = inHumidity
        rtl_433/<host>/devices/Fineoffset-WH25/170/pressure_hPa = pressure

The weewx/loop topic isn’t used by anything yet. It’s there so a Home Assistant automation can publish a TIME:0,extraTemp1:21.5,... payload later without touching the driver again.

pressure is station pressure, which is what the WH25 measures. barometer still comes from the Vevor. [StdWXCalculate] has both set to prefer_hardware, so weewx uses the measured value when a packet has one and computes it otherwise.

The # that wasn’t a wildcard

The first restart looked fine in the log, until I read the subscription line:

INFO user.wxMesh: wxMesh: subscribed to rtl_433/<host>/devices/Fineoffset-WH25/170/

The trailing # was gone. weewx.conf is a ConfigObj file, and in ConfigObj an unquoted # starts an inline comment. The driver had subscribed to a topic that nothing publishes to. Quoting the values in the topic list fixed it. It’s an easy mistake to make with MQTT, where # shows up in almost every subscription.

Checking

journalctl -u weewx | grep wxMesh

INFO user.wxMesh: wxMesh 0.1-pi3-1: broker <broker-address>:1883, client id weewx-pi3-1, ...
INFO user.wxMesh: wxMesh: connected to <broker-address>:1883 with result code 0
INFO user.wxMesh: wxMesh: subscribed to rtl_433/<host>/devices/Fineoffset-WH25/170/#
INFO user.wxMesh: wxMesh: subscribed to weewx/loop

Then the next archive record, from the venv’s sqlite3 module:

20:00:00  inTemp=75.68  inHumidity=46.0  pressure=29.8185  barometer=29.93  outTemp=67.25
19:55:00  inTemp=None   inHumidity=None  pressure=29.8142  barometer=29.93  outTemp=67.4

24.3 °C in, 75.68 °F out, in the same row as the Vevor’s outdoor temperature.

Gotchas, collected

• Quote topics containing # in weewx.conf, or the wildcard is eaten as a comment.
• MetaDriver never restarts a failed child. Make sure the secondary driver can’t raise during construction. connect_async() instead of connect() is the whole fix for MQTT.
• A wildcard subscription needs a whitelist. Map the fields you want and drop the rest, or battery_ok, mic and friends end up in the packets.
• paho-mqtt 2.x needs CallbackAPIVersion. Any weewx MQTT driver written before 2024 will hit this.
• Restarts log a warning from MetaDriver: “worker thread for driver ‘Interceptor’ did not close within 5.0 seconds”. Each child’s generator blocks until its next packet, so the stop takes a little longer. The threads are daemons and the process exits anyway.
• Stay with record_generation = software. It’s what lets packets from two drivers share one archive record.

The Pi now records an outdoor station that thinks it’s talking to Weather Underground and an indoor sensor that arrives over MQTT from a different computer, in one weewx, with one archive.

I wanted the data on my own hardware, recorded by weewx, and I didn’t want an inexpensive IoT console on my LAN or talking to the internet at all.

The end state: a Raspberry Pi 3 (pi3-1) runs its own WPA2 access point just for the station. On that network the Pi’s DNS server says it is wunderground.com. The station uploads to the Pi, thinking it’s Weather Underground, and weewx-interceptor parses the upload and hands it to weewx. The station can’t reach the LAN or the internet, and the weewx reports are served to the LAN by nginx.

How it fits together

Vevor console --wifi (WPA2, SSID weewx-ap)--> Pi wlan0 192.168.5.1
  DHCP + DNS: dnsmasq
    wunderground.com -> 192.168.5.1
    every other name -> NXDOMAIN, nothing forwarded upstream
  HTTP to port 80 --nftables redirect--> :8090 weewx-interceptor (wu-client)
    --> weewxd --> SQLite archive
  weewx reports --> /var/www/weewx --> nginx on port 80 (eth0, LAN)
  IP forwarding off + nftables drops all forwarding to/from wlan0

The station sends a Weather Underground protocol request, a plain HTTP GET to /weatherstation/updateweatherstation.php?ID=...&tempf=...&humidity=..., and the interceptor’s wu-client mode already understands that format. Getting the station to send that request to the Pi only takes a DNS lie and a port redirect.

Hardware and host

• Raspberry Pi 3B, Raspberry Pi OS based on Debian 13 (trixie), wired to the LAN on eth0
• The Pi 3’s built-in BCM43430 wifi (brcmfmac driver, 2.4 GHz only) as the access point on wlan0
• Vevor weather station console with a BL602 wifi chip

The Pi already runs another service that uses port 8080, which is why the interceptor listens on 8090 here.

1. Base system

apt-get update && apt-get install -y git hostapd dnsmasq nginx
timedatectl set-timezone America/Los_Angeles
raspi-config nonint do_wifi_country US
rfkill unblock wifi

2. weewx and the interceptor

I installed weewx 5.5 with the git method, in a Python venv. Do this as your normal user, not root. weectl station create writes the current user and the venv’s Python path into the systemd unit it generates.

python3 -m venv ~/weewx-venv
source ~/weewx-venv/bin/activate
python3 -m pip install --upgrade pip
python3 -m pip install CT3 configobj Pillow ephem
git clone https://github.com/weewx/weewx ~/weewx

python3 ~/weewx/src/weectl.py station create --no-prompt \
  --driver=weewx.drivers.simulator --location="Rocklin, CA" \
  --latitude=<lat> --longitude=<lon> --altitude=<alt>,foot --units=us

python3 ~/weewx/src/weectl.py extension install --yes \
  https://github.com/matthewwall/weewx-interceptor/archive/master.zip

The simulator driver is only there so station create has something to configure. It gets replaced in the next step. Then, as root, install the service:

sh ~<user>/weewx-data/scripts/setup-daemon.sh

3. weewx.conf

The relevant changes in ~/weewx-data/weewx.conf:

[Station]
    station_type = Interceptor

[Interceptor]
    driver = user.interceptor
    device_type = wu-client
    port = 8090

[StdReport]
    HTML_ROOT = /var/www/weewx

[StdArchive]
    archive_interval = 300
    record_generation = software

Two notes:

• record_generation must be software. The interceptor has no hardware archive memory to read records from. With hardware, weewx starts up and logs loop packets, but it never saves an archive record.
• HTML_ROOT points outside the home directory, at a directory the weewx user owns. Home directories on this Pi are mode 700, so nginx can’t read the default ~/weewx-data/public_html. The smartphone and mobile sub-reports need their HTML_ROOT moved under /var/www/weewx too.

4. Patching the interceptor

Version 0.60 of the interceptor needed four small fixes for this station, all in ~/weewx-data/bin/user/interceptor.py. Keep a copy of the original, because reinstalling the extension overwrites your patches.

@@ do_POST
-            data = str(self.rfile.read(length))
+            data = _bytes_to_str(self.rfile.read(length))

@@ WUClient LABEL_MAP
             'solarradiation': 'solar_radiation',
+            'solarRadiation': 'solar_radiation',

@@ WUClient IGNORED_LABELS
+            'rainin',

@@ WUClient.Parser.parse
-                pkt['dateTime'] = self.decode_datetime(
-                    data.pop('dateutc', int(time.time() + 0.5)))
+                # Console clock is 1 h fast (no DST) and has no NTP: use the Pi clock
+                data.pop('dateutc', None)
+                pkt['dateTime'] = int(time.time() + 0.5)

What each one fixes:

1. Python 3 bytes bug. str() on a bytes object gives you the string "b'...'", not the decoded body. The parsed values then fail with could not convert string to float. The module already has a _bytes_to_str helper. It just wasn’t used here.
2. camelCase label. The Vevor sends solarRadiation where the interceptor expects solarradiation. Without the extra mapping, the log fills with “unrecognized parameter” warnings and solar radiation is never recorded.
3. Rain. The station sends both rainin (rain in the last hour) and dailyrainin. weewx works out rain per interval from the running daily total, so rainin is ignored to avoid counting the same rain twice.
4. Timestamps. The console’s clock was an hour ahead. It doesn’t handle daylight saving time, and on an isolated network it can’t reach an NTP server to correct itself. Records were being stamped an hour in the future. The Pi’s clock is correct, so the patch ignores dateutc and stamps each packet when it arrives.

5. The access point: hostapd, not NetworkManager

This part took the most time.

Raspberry Pi OS uses NetworkManager, and NetworkManager can run a wifi hotspot. An open hotspot worked fine. A WPA2 hotspot never completed a handshake with any client, not just the weather station. A kernel and firmware upgrade didn’t change that. Switching to plain hostapd got WPA2 working.

First, tell NetworkManager to leave wlan0 alone (/etc/NetworkManager/conf.d/99-weewx-ap.conf):

[keyfile]
unmanaged-devices=interface-name:wlan0

Then /etc/hostapd/hostapd.conf:

interface=wlan0
driver=nl80211
ssid=weewx-ap
country_code=US
ieee80211d=1
hw_mode=g
channel=6
ieee80211n=1
wmm_enabled=1
macaddr_acl=0
auth_algs=1
ignore_broadcast_ssid=0
wpa=2
wpa_key_mgmt=WPA-PSK
wpa_pairwise=CCMP
rsn_pairwise=CCMP
ieee80211w=0
wpa_passphrase=<your passphrase>
eapol_version=1
wpa_pairwise_update_count=10

The slow handshake

Even with hostapd and the default settings, the weather station failed to join about nine times out of ten. With debug logging on, hostapd showed the reason:

WPA: PTKSTART: Retry limit 4 reached

The station’s BL602 wifi chip is slow to answer the WPA2 4-way handshake. hostapd sends message 1, waits, resends, and gives up before the station replies. The last two lines of the config fix it:

• wpa_pairwise_update_count=10 lets hostapd resend handshake messages up to 10 times instead of 4, so a slow client has time to answer.
• eapol_version=1 makes hostapd use the older EAPOL version, which some embedded wifi stacks handle better.

After that change, the station joined on the first try every time. If you turned up hostapd’s logging to debug this (logger_syslog_level=0), turn it back down afterwards.

6. DHCP and the DNS lie

/etc/dnsmasq.d/weewx-ap.conf:

interface=wlan0
bind-interfaces
except-interface=lo
dhcp-range=192.168.5.10,192.168.5.254,1h
dhcp-option=option:router,192.168.5.1
dhcp-option=option:dns-server,192.168.5.1

# Never forward upstream. Only wunderground.com resolves, to this Pi.
no-resolv
no-poll
address=/wunderground.com/192.168.5.1
address=/#/

address=/wunderground.com/... covers the domain and all its subdomains, so rtupdate.wunderground.com and weatherstation.wunderground.com both resolve to the Pi. address=/#/ with no address answers every other name with NXDOMAIN. no-resolv means dnsmasq never asks an upstream server, so the station can’t learn a real address for anything.

I used 192.168.5.0/24 for the AP subnet because the console’s own setup hotspot uses 192.168.4.1, and I didn’t want the two to overlap.

7. Redirect and isolation firewall

A small script sets the address on wlan0 and loads an nftables table, at /usr/local/sbin/weewx-ap-net (mode 755):

#!/bin/sh
set -e
ip link set wlan0 up
ip addr replace 192.168.5.1/24 dev wlan0
nft delete table inet weewx 2>/dev/null || true
nft -f - <<'NFT'
table inet weewx {
	chain prerouting {
		type nat hook prerouting priority dstnat; policy accept;
		iifname "wlan0" tcp dport 80 counter redirect to :8090
		iifname "wlan0" tcp dport 443 counter
	}
	chain input {
		type filter hook input priority filter; policy accept;
		iifname != "wlan0" accept
		ct state established,related accept
		udp dport 67 accept
		meta l4proto { tcp, udp } th dport 53 accept
		tcp dport 8090 accept
		icmp type echo-request accept
		counter drop
	}
	chain forward {
		type filter hook forward priority filter; policy accept;
		iifname "wlan0" counter drop
		oifname "wlan0" counter drop
	}
}
NFT

• prerouting sends the station’s HTTP requests to the interceptor. The port 443 rule only counts packets, so you can see whether the station ever tries HTTPS.
• input lets wifi clients reach DHCP, DNS, the interceptor and ping, and nothing else on the Pi. SSH and nginx can’t be reached from wlan0.
• forward drops all traffic to or from wlan0. IP forwarding is also left off (no net.ipv4.ip_forward=1, no masquerade), so the isolation doesn’t depend on a single setting.

A oneshot unit runs the script at boot (/etc/systemd/system/weewx-ap-net.service):

[Unit]
Description=weewx AP: wlan0 address, port redirect and isolation firewall
Before=hostapd.service dnsmasq.service
After=NetworkManager.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/local/sbin/weewx-ap-net

[Install]
WantedBy=multi-user.target

hostapd and dnsmasq each get a drop-in (/etc/systemd/system/hostapd.service.d/weewx-ap.conf and the same path for dnsmasq.service.d):

[Unit]
After=weewx-ap-net.service
Wants=weewx-ap-net.service

Use Wants=, not Requires=. With Requires=, restarting weewx-ap-net to reload the firewall also restarts hostapd, and the station is kicked off the network.

systemctl daemon-reload
systemctl unmask hostapd
systemctl enable --now weewx-ap-net hostapd dnsmasq

8. Serving the reports

/etc/nginx/sites-available/weewx:

server {
    listen 80 default_server;
    listen [::]:80 default_server;
    server_name _;
    root /var/www/weewx;
    index index.html;
    location / { try_files $uri $uri/ =404; }
}

rm /etc/nginx/sites-enabled/default
ln -s /etc/nginx/sites-available/weewx /etc/nginx/sites-enabled/weewx
systemctl reload nginx

LAN clients get the weewx Seasons report at http://<pi-address>/. Devices on the station’s wifi can’t load it, because port 80 on wlan0 goes to the interceptor. That’s fine, since the station is the only thing on that network.

9. Pointing the console at it

On the Vevor console’s setup page, join the weewx-ap network and enable Weather Underground with any station ID and key (1234 works, since the interceptor doesn’t check them). WeatherCloud can stay enabled. Its DNS lookups get NXDOMAIN and it quietly fails.

Checking that it works

iw dev wlan0 station dump                 # station is associated
cat /var/lib/misc/dnsmasq.leases          # and got a 192.168.5.x lease
journalctl -u hostapd | grep "handshake completed"
nft list table inet weewx                 # port-80 counter rising, drop counters at 0
journalctl -u weewx -f                    # "Added record ..." every 5 minutes
curl http://<pi-address>/                 # weewx Seasons page

In nft list table inet weewx, the port 80 redirect counter should go up with every upload. The forward drop counters should stay at zero. If they start climbing, the station is trying to reach something other than “Weather Underground”.

Gotchas, collected

• NetworkManager’s WPA2 hotspot on the Pi 3 (brcmfmac) never completed a handshake. An open hotspot worked. hostapd fixed it.
• The BL602 chip answers the handshake slowly. Set wpa_pairwise_update_count=10 and eapol_version=1, or expect “Retry limit 4 reached”.
• The interceptor’s POST handling has a Python 3 bug, which shows up as could not convert string to float.
• record_generation = hardware saves no records with the interceptor. Use software.
• The console clock is an hour fast and can’t sync on an isolated network, so use the Pi’s clock for timestamps.
• Don’t overlap the console’s setup subnet (192.168.4.x).
• sqlite3 isn’t installed by default. Query the archive with the venv’s Python sqlite3 module instead of installing the CLI.
• Run git in ~/weewx as the weewx user. As root, git refuses with a “dubious ownership” error.

The station now posts its “Weather Underground” updates to a Pi in the same house. The station has no idea, and Weather Underground never hears from it.