Read the parity the way the sensors write it
Their sensors are on the air, five of them, and every message was arriving
intact. The bytes they sent, recovered from their own capture:
A7 1B 44 A6 09 4B 00 channel B id 271B 22.7 C 38%
F9 35 44 2B 09 C9 6F channel A id 3935 22.5 C 43%
21 E5 84 1E 0A 9F 51 channel C id 21E5 31.1 C 30% battery low
F9 7D 44 28 09 50 3B channel A id 397D 23.2 C 40%
0D D6 44 A9 09 CF A8 channel C id 0DD6 23.1 C 41%
Every checksum correct, every message type 0x04, every reading plausible. The
framing was right, the bit offset was right, the byte order was right, the
pulses had been recovered perfectly for days. One bit of convention was
wrong: the parity in the top bit of each payload byte is even, and this
required it to be odd. Twenty payload bytes across five independent messages,
every one of them even, which is not something twenty bytes do by chance.
That is the whole fault. Everything else changed in this and the two commits
before it was real and worth doing, and none of it was why nothing decoded.
Three things follow.
The five messages are now a test, checked byte for byte against the weather
they carry. They are worth more than everything else in that file put
together: every other test there puts a reading in through an encoder written
from the same description as the decoder, so the two agree by construction and
agree about anything they are both wrong about -- which is exactly what
happened. An encoder tested against its own decoder cannot find a fault in
the description they share, and no amount of it would ever have found this.
The emptiness check earns its place now. Odd parity rejects a byte of all
zeroes; even parity accepts one, so a run of silence read as zeroes satisfies
both the parity and a sum of zero, and the only thing standing between that
and a display full of sensors is the test that some byte is non-zero. It was
there for tidiness and is now load-bearing; the comment says so.
And the readings of a burst are tried in order and the search stops at the
first that yields anything, rather than pooling them. Half a dozen readings
at two byte orders is sixteen times the chances for a coincidence to satisfy a
twelve-bit check, and sensors that were not there began appearing in the
invented garden the moment the alternatives went in -- caught by the test that
asks whether everything heard is something that exists. Stopping early costs
nothing: a burst that reads correctly the ordinary way never reaches the
alternatives, and one that does not reaches them exactly as before.
Full suite 2351 passed, checked against three more deliberately broken builds.
Sixty seconds of receiver noise yields nothing and eight hundred seconds of
the invented garden yields no sensor that is not there. Built as
2026-09-07_05.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016PsWPTweCT6pwxKngvVxcg
This commit is contained in:
The Dust Council
parent
dfea5cb2f2
commit
872eadac37
6 changed files with 193 additions and 36 deletions
|
|
@ -31,6 +31,101 @@ def heard(bits, coding="pwm", rate=RATE, offset=OFFSET, noise=0.05,
|
|||
return a.readings_from(iq, rate, offset=offset)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Messages off real sensors
|
||||
# ---------------------------------------------------------------------------
|
||||
#
|
||||
# Five 592TXR messages recovered from the air by somebody who owns the
|
||||
# sensors, checked here byte for byte. They are worth more than everything
|
||||
# below them put together: every other test in this file puts a reading in
|
||||
# through an encoder written from the same description as the decoder, so the
|
||||
# two agree by construction and agree about anything they are both wrong
|
||||
# about. These do not come from here, and the one thing they caught is the
|
||||
# thing that construction could never catch.
|
||||
#
|
||||
# What they caught was the parity. This read the top bit of every payload
|
||||
# byte as odd parity; these five say it is even, twenty payload bytes out of
|
||||
# twenty, which is not something twenty bytes do by accident. Nothing was
|
||||
# decoded at all until they arrived.
|
||||
|
||||
REAL_MESSAGES = [
|
||||
# (bytes, channel, id, temperature, humidity, battery low)
|
||||
("A7 1B 44 A6 09 4B 00", "B", "271B", 22.7, 38, False),
|
||||
("F9 35 44 2B 09 C9 6F", "A", "3935", 22.5, 43, False),
|
||||
("21 E5 84 1E 0A 9F 51", "C", "21E5", 31.1, 30, True),
|
||||
("F9 7D 44 28 09 50 3B", "A", "397D", 23.2, 40, False),
|
||||
("0D D6 44 A9 09 CF A8", "C", "0DD6", 23.1, 41, False),
|
||||
]
|
||||
|
||||
|
||||
def as_bits(text):
|
||||
return "".join(format(int(byte, 16), "08b") for byte in text.split())
|
||||
|
||||
|
||||
@pytest.mark.parametrize("text,channel,sensor,celsius,humidity,flat",
|
||||
REAL_MESSAGES)
|
||||
def test_a_message_off_a_real_sensor_reads_as_the_weather_it_was(
|
||||
text, channel, sensor, celsius, humidity, flat):
|
||||
got = a.decode(as_bits(text), confirm=False)
|
||||
assert got is not None, "a real message this program could not read"
|
||||
assert got.family == "tower" and got.sensor == sensor
|
||||
assert got.channel == channel
|
||||
assert got.value("temperature") == pytest.approx(celsius, abs=0.05)
|
||||
assert got.value("humidity") == humidity
|
||||
assert got.battery_low is flat
|
||||
|
||||
|
||||
@pytest.mark.parametrize("text,_c,_s,_t,_h,_b", REAL_MESSAGES)
|
||||
def test_the_payload_bytes_of_a_real_message_carry_even_parity(text, _c, _s,
|
||||
_t, _h, _b):
|
||||
"""Stated on its own, because it is the whole of what went wrong.
|
||||
|
||||
Held the other way round, this decoded nothing whatever -- not badly, not
|
||||
occasionally, but nothing at all -- while every other check in the format
|
||||
passed and said so.
|
||||
"""
|
||||
data = [int(byte, 16) for byte in text.split()]
|
||||
assert all(a.parity8(byte) == 0 for byte in data[2:-1])
|
||||
assert (sum(data[:-1]) & 0xFF) == data[-1]
|
||||
|
||||
|
||||
def test_a_real_message_survives_the_whole_path_from_the_air():
|
||||
"""Keyed at the timings their receiver actually measured.
|
||||
|
||||
Four sync pulses at 612 microseconds, data at 216 and 403 with gaps that
|
||||
complete the bit period, and the terminating pulse a real transmitter
|
||||
sends after the last bit -- which nothing here had ever seen, because
|
||||
nothing here had ever sent one.
|
||||
"""
|
||||
text = REAL_MESSAGES[0][0]
|
||||
bits = as_bits(text)
|
||||
pairs = ([(612.0, 601.0)] * 4
|
||||
+ [(403.0, 209.0) if bit == "1" else (216.0, 395.0)
|
||||
for bit in bits]
|
||||
+ [(216.0, 0.0)]) # the terminator, carrying no bit
|
||||
got = a.readings_from(keyed_at(bits, pairs, reset_us=9_000.0), 250_000.0)
|
||||
assert [r.sensor for r in got] == ["271B"]
|
||||
assert got[0].value("temperature") == pytest.approx(22.7, abs=0.05)
|
||||
|
||||
|
||||
def test_a_burst_off_a_real_sensor_is_sixty_one_pulses_and_not_sixty():
|
||||
"""Fifty-six bits of message, four of sync, and one to close the last bit.
|
||||
|
||||
Worth pinning because everything here was written against sixty, the
|
||||
simulator not sending the terminating pulse that real hardware does, and
|
||||
"it happens to work anyway" is not a thing to leave unrecorded.
|
||||
"""
|
||||
bits = as_bits(REAL_MESSAGES[0][0])
|
||||
pairs = ([(612.0, 601.0)] * 4
|
||||
+ [(403.0, 209.0) if bit == "1" else (216.0, 395.0)
|
||||
for bit in bits]
|
||||
+ [(216.0, 0.0)])
|
||||
iq = keyed_at(bits, pairs, reset_us=9_000.0)
|
||||
found = a.bursts(*a.baseband(iq, 250_000.0, 0.0))
|
||||
assert found and all(b.pulses == 61 for b in found)
|
||||
assert len(bits) == 56
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# The tower sensor: what most people have
|
||||
# ---------------------------------------------------------------------------
|
||||
|
|
@ -734,7 +829,9 @@ def test_the_pulse_lengths_of_a_burst_are_reported_as_the_protocol_shape():
|
|||
noise=0.02), RATE, OFFSET))[0]
|
||||
marks = a.timings(burst.marks)
|
||||
assert len(marks) == 3 # short, long, sync
|
||||
assert [n for _v, n in marks] == [28, 28, 4]
|
||||
short, long, sync = (n for _v, n in marks)
|
||||
assert sync == 4 # the sync pulses
|
||||
assert short + long == 56 # one per bit of the message
|
||||
assert [round(v / 10) * 10 for v, _n in marks] == [220, 400, 600]
|
||||
assert sum(n for _v, n in marks) == burst.pulses
|
||||
|
||||
|
|
@ -964,15 +1061,15 @@ def test_a_message_is_read_from_whichever_end_of_a_byte_it_arrives(order):
|
|||
def test_reading_a_byte_backwards_keeps_its_parity_and_breaks_its_sum():
|
||||
"""The signature that names this fault, which is why it is worth having.
|
||||
|
||||
Reversing the bits of a byte does not change how many are set, so odd
|
||||
parity survives it; a checksum does not. A message read from the wrong
|
||||
end therefore shows every parity holding and the sum failing, on every
|
||||
copy -- which is a fingerprint rather than a guess.
|
||||
Reversing the bits of a byte does not change how many are set, so parity
|
||||
survives it; a checksum does not. A message read from the wrong end
|
||||
therefore shows every parity holding and the sum failing, on every copy
|
||||
-- which is a fingerprint rather than a guess.
|
||||
"""
|
||||
frame = a.tower_frame(0x1A2B, 21.5, 48, "A")
|
||||
backwards = reversed_bytes(frame)
|
||||
plain = [int(backwards[i:i + 8], 2) for i in range(0, len(backwards), 8)]
|
||||
assert all(a.parity8(byte) == 1 for byte in plain[2:-1])
|
||||
assert all(a.parity8(byte) == 0 for byte in plain[2:-1])
|
||||
assert (sum(plain[:-1]) & 0xFF) != plain[-1]
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue