feat(repeater/analyzer): multi-path join key + prefer direct 0-hop path

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
tthandClaude Opus 4.8 committed 2026-07-12 18:47:44 +02:00
1 parent 8f602facb2
commit 6c4f7af41f
2 files changed
+61 -24

No files matched your search

+53 -23
View File
@@ -87,40 +87,80 @@ void MyMesh::putNeighbour(const mesh::Identity &id, uint32_t timestamp, float sn
#endif
}
#if MAX_HEARD_NODES || RXLOG_SIZE
// Cheap deterministic frame id: FNV-1a over (type || payload). Same value for
// every copy of one advert/packet regardless of the path it took (path is not
// hashed), so it GROUPS the copies that arrived via different paths -> the bridge
// joins nodes<->rxlog on it to reconstruct multi-path. NOT the SHA packet-hash
// (the mesh already computes that once per frame in hasSeen(); a second SHA on
// the radio hot path would be wasted work).
static uint32_t analyzer_frame_id(const mesh::Packet* pkt) {
uint32_t h = 2166136261u;
uint8_t t = pkt->getPayloadType();
h = (h ^ t) * 16777619u;
for (uint16_t k = 0; k < pkt->payload_len; k++) h = (h ^ pkt->payload[k]) * 16777619u;
return h;
}
#endif
#if MAX_HEARD_NODES
// CUSTOM (TeTeHacko): record/update one heard node in the analyzer registry.
void MyMesh::putHeardNode(const mesh::Identity& id, uint32_t advert_timestamp, uint8_t type,
int32_t lat, int32_t lon, const char* name,
int8_t snr, int8_t rssi, const mesh::Packet* pkt) {
uint32_t now = getRTCClock()->getCurrentTime();
bool is_direct = (pkt->getPathHashCount() == 0); // 0-hop = heard directly
uint32_t oldest = 0xFFFFFFFF;
HeardNode* slot = &heard_nodes[0];
bool existing = false;
for (int i = 0; i < MAX_HEARD_NODES; i++) {
HeardNode* n = &heard_nodes[i];
if (n->heard_timestamp > 0 && memcmp(n->pub_prefix, id.pub_key, HEARD_NODE_PREFIX) == 0) {
slot = n; break; // update existing entry
slot = n; existing = true; break; // update existing entry
}
if (n->heard_timestamp < oldest) { oldest = n->heard_timestamp; slot = n; } // else evict LRU
}
if (!existing) *slot = HeardNode(); // reused/evicted slot -> clear stale fields (direct_heard!)
// latest identity / position / name always win
memcpy(slot->pub_prefix, id.pub_key, HEARD_NODE_PREFIX);
slot->advert_timestamp = advert_timestamp;
slot->heard_timestamp = now;
slot->type = type;
slot->lat = lat;
slot->lon = lon;
slot->snr = snr;
slot->rssi = rssi;
StrHelper::strncpy(slot->name, name ? name : "", sizeof(slot->name));
slot->path_len = (uint8_t) pkt->path_len;
uint8_t pb = pkt->getPathByteLen();
if (pb > ANALYZER_PATH_LEN) pb = ANALYZER_PATH_LEN;
memset(slot->path, 0, sizeof(slot->path));
if (pb) memcpy(slot->path, pkt->path, pb);
slot->pkt_hash = analyzer_frame_id(pkt); // join key -> rxlog copies (= every path this advert took)
// Representative path + link quality. A DIRECT (0-hop) advert is the key edge
// (us <-> node). Because all copies of one advert share a hash, dedup means
// onAdvertRecv only fires for whichever copy arrives first -- often a stronger
// relayed one -- so a plain last-write keeps overwriting a direct link with a
// relayed path. Prefer the direct observation for HEARD_DIRECT_TTL_SECS. (Full
// multi-path is reconstructed on the bridge via the pkt_hash join to rxlog.)
bool direct_recent = slot->direct_heard != 0 && (now - slot->direct_heard) < HEARD_DIRECT_TTL_SECS;
if (is_direct) {
slot->direct_heard = now;
slot->snr = snr; slot->rssi = rssi;
slot->path_len = 0; // empty path = direct
memset(slot->path, 0, sizeof(slot->path));
} else if (!direct_recent) {
slot->snr = snr; slot->rssi = rssi;
slot->path_len = (uint8_t) pkt->path_len;
uint8_t pb = pkt->getPathByteLen();
if (pb > ANALYZER_PATH_LEN) pb = ANALYZER_PATH_LEN;
memset(slot->path, 0, sizeof(slot->path));
if (pb) memcpy(slot->path, pkt->path, pb);
}
// else: relayed advert but heard direct recently -> keep the direct path/SNR
}
// `nodes [offset]` -> paged dump of the heard-node registry (newest first).
// One text line per node: N,<prefix-hex>,<type>,<lat*1e6>,<lon*1e6>,<snr*4>,<rssi>,<secs_ago>,<path-hex>,<name>
// Trailer line: E,<next_offset>,<total>
// One text line per node: N,<prefix-hex>,<type>,<lat*1e6>,<lon*1e6>,<snr*4>,<rssi>,<secs_ago>,<pkthash-hex>,<path-hex>,<name>
// <pkthash> = join key: group `rxlog` records by it to get EVERY path this
// node's advert arrived by (multi-path). <path> is a single representative
// (direct/0-hop preferred). Trailer line: E,<next_offset>,<total>
void MyMesh::formatNodesReply(char* reply, uint16_t offset) {
char* dp = reply;
int total = 0;
@@ -143,10 +183,10 @@ void MyMesh::formatNodesReply(char* reply, uint16_t offset) {
uint8_t cnt = n->path_len & 63, sz = (n->path_len >> 6) + 1;
uint8_t pb = cnt * sz; if (pb > ANALYZER_PATH_LEN) pb = ANALYZER_PATH_LEN;
if (pb) mesh::Utils::toHex(pathhex, n->path, pb); else pathhex[0] = 0;
snprintf(line, sizeof(line), "N,%s,%u,%ld,%ld,%d,%d,%lu,%s,%s\n",
snprintf(line, sizeof(line), "N,%s,%u,%ld,%ld,%d,%d,%lu,%08lX,%s,%s\n",
prefix, (unsigned)n->type, (long)n->lat, (long)n->lon,
(int)n->snr, (int)n->rssi, (unsigned long)(now - n->heard_timestamp),
pathhex, n->name);
(unsigned long)n->pkt_hash, pathhex, n->name);
int ll = strlen(line);
if (i > offset && (dp - reply) + ll + 24 > 150) break; // room for trailer; always emit >=1
memcpy(dp, line, ll); dp += ll;
@@ -164,17 +204,7 @@ void MyMesh::captureRx(const mesh::Packet* pkt) {
r->seq = rxlog_next_seq++;
if (rxlog_next_seq == 0) rxlog_next_seq = 1; // wrap guard (seq 0 reserved for empty)
r->when = getRTCClock()->getCurrentTime();
// Cheap deterministic frame id via FNV-1a over (type || payload) -- NOT a
// per-packet SHA-256. The mesh already computes the crypto packet hash once
// per frame (hasSeen); calling calculatePacketHash() here too would double
// the crypto load on the radio hot path for no benefit. FNV is a fraction of
// the cost and still lets nodes running this FW dedup / correlate the same
// frame. (This is NOT the MeshCore SHA packet-hash.)
uint32_t fnv = 2166136261u;
uint8_t t = pkt->getPayloadType();
fnv = (fnv ^ t) * 16777619u;
for (uint16_t k = 0; k < pkt->payload_len; k++) fnv = (fnv ^ pkt->payload[k]) * 16777619u;
r->pkt_hash = fnv;
r->pkt_hash = analyzer_frame_id(pkt); // same key across all copies -> groups the paths a frame took
r->snr = pkt->_snr;
r->rssi = (int8_t) pkt->getRSSI();
r->header = pkt->header;
+8 -1
View File
@@ -99,6 +99,9 @@ struct NeighbourInfo {
#ifndef ANALYZER_PATH_LEN
#define ANALYZER_PATH_LEN 16 // max hop-hash bytes kept per record
#endif
#ifndef HEARD_DIRECT_TTL_SECS
#define HEARD_DIRECT_TTL_SECS 3600 // keep showing a node as direct (0-hop) this long after last hearing it direct
#endif
#if MAX_HEARD_NODES
struct HeardNode {
@@ -107,10 +110,14 @@ struct HeardNode {
int32_t lat, lon; // degrees x 1e6, 0 = unknown
uint32_t heard_timestamp; // epoch when last heard (0 = empty slot)
uint32_t advert_timestamp; // advert's own timestamp (newest wins)
uint32_t pkt_hash; // FNV of the latest advert (type||payload) -- JOIN KEY:
// group rxlog records by this to get every path the
// advert arrived by (rxlog logs all copies pre-dedup)
uint32_t direct_heard; // epoch we last heard this node 0-hop (0 = never)
int8_t snr; // x4
int8_t rssi; // dBm
uint8_t type; // ADV_TYPE_*
uint8_t path_len; // bit-packed (hash size|count) as heard
uint8_t path_len; // bit-packed (hash size|count); representative/best path
uint8_t path[ANALYZER_PATH_LEN];
};
#endif