Merge remote-tracking branch 'upstream/pr-2367' into keymindCascade
# Conflicts: # build-iotthinks.sh # build.sh # docs/cli_commands.md # examples/companion_radio/MyMesh.cpp # examples/companion_radio/main.cpp # examples/simple_repeater/MyMesh.cpp # examples/simple_repeater/MyMesh.h # src/helpers/CommonCLI.cpp # src/helpers/CommonCLI.h # src/helpers/ESP32Board.h # src/helpers/SimpleMeshTables.h # src/helpers/sensors/EnvironmentSensorManager.cpp # variants/heltec_ct62/platformio.ini # variants/heltec_t096/T096Board.cpp # variants/heltec_t096/platformio.ini # variants/heltec_tracker/platformio.ini # variants/heltec_tracker_v2/platformio.ini # variants/heltec_v2/platformio.ini # variants/heltec_v3/platformio.ini # variants/heltec_v4/HeltecV4Board.cpp # variants/heltec_v4/platformio.ini # variants/heltec_wireless_paper/platformio.ini # variants/lilygo_tbeam_1w/platformio.ini # variants/lilygo_tbeam_SX1262/platformio.ini # variants/lilygo_tbeam_SX1276/platformio.ini # variants/lilygo_tbeam_supreme_SX1262/platformio.ini # variants/lilygo_tlora_v2_1/platformio.ini # variants/xiao_c3/platformio.ini # variants/xiao_s3/platformio.ini # variants/xiao_s3_wio/platformio.ini
This commit is contained in:
commit
4813b9eea4
18 files changed
+1244
-160
No files matched your search
+242
-61
@@ -28,25 +28,12 @@ This document provides an overview of CLI commands that can be sent to MeshCore
|
||||
**Usage:**
|
||||
- `reboot`
|
||||
|
||||
**Note:** No reply is sent.
|
||||
|
||||
---
|
||||
|
||||
### Power-off the node
|
||||
**Usage:**
|
||||
- `poweroff`, or
|
||||
- `shutdown`
|
||||
|
||||
**Note:** No reply is sent.
|
||||
|
||||
---
|
||||
|
||||
### Reset the clock and reboot
|
||||
**Usage:**
|
||||
- `clkreboot`
|
||||
|
||||
**Note:** No reply is sent.
|
||||
|
||||
---
|
||||
|
||||
### Sync the clock with the remote device
|
||||
@@ -232,20 +219,6 @@ This document provides an overview of CLI commands that can be sent to MeshCore
|
||||
|
||||
---
|
||||
|
||||
#### View or change the boosted receive gain mode
|
||||
**Usage:**
|
||||
- `get radio.rxgain`
|
||||
- `set radio.rxgain <state>`
|
||||
|
||||
**Parameters:**
|
||||
- `state`: `on`|`off`
|
||||
|
||||
**Default:** `off`
|
||||
|
||||
**Note:** Only available on SX1262 and SX1268 based boards.
|
||||
|
||||
---
|
||||
|
||||
#### Change the radio parameters for a set duration
|
||||
**Usage:**
|
||||
- `tempradio <freq>,<bw>,<sf>,<cr>,<timeout_mins>`
|
||||
@@ -458,18 +431,6 @@ This document provides an overview of CLI commands that can be sent to MeshCore
|
||||
|
||||
---
|
||||
|
||||
#### View or set reboot interval (Repeater and room server)
|
||||
**Usage:**
|
||||
- `get reboot.interval`
|
||||
- `set reboot.interval <hours>`
|
||||
|
||||
**Parameters:**
|
||||
- `hours`: 0-255. 0 is disabled
|
||||
|
||||
**Default:** `0` (disabled)
|
||||
|
||||
---
|
||||
|
||||
### Routing
|
||||
|
||||
#### View or change this node's repeat flag
|
||||
@@ -699,7 +660,7 @@ This document provides an overview of CLI commands that can be sent to MeshCore
|
||||
**Parameters:**
|
||||
- `value`: Maximum flood hop count (0-64) for a packet without a scope (no region set)
|
||||
|
||||
**Default:** `64` - (`0xFF` indicates it hasn't been set, will track flood.max until it is.)
|
||||
**Default:** `0xFF` - indicates it hasn't been set, will track flood.max until it is.
|
||||
|
||||
**Note:** An alternative to `region denyf *`, setting `flood.max.unscoped` to a lower value such as `3` would allow for local unscoped messages to propagate, while preventing noisy neighbors from flooding a local region.
|
||||
|
||||
@@ -830,27 +791,6 @@ This document provides an overview of CLI commands that can be sent to MeshCore
|
||||
|
||||
---
|
||||
|
||||
#### View or set the direct path override for the current remote client
|
||||
**Usage:**
|
||||
- `get outpath`
|
||||
- `set outpath <hop1_hex,hop2_hex,...>`
|
||||
- `set outpath direct`
|
||||
- `set outpath clear`
|
||||
- `set outpath flood`
|
||||
|
||||
**Parameters:**
|
||||
- `hopN_hex`: Hop hash, `2`, `4`, or `6` hex characters. All hops must use the same width.
|
||||
|
||||
**Notes:**
|
||||
- These commands require remote client context (they target the caller's ACL entry).
|
||||
- The path hash size is inferred from the hop hash width.
|
||||
- `outpath` overrides the primary direct route used for replies to the caller.
|
||||
- `direct` sets a zero-hop direct route for a caller reachable without repeaters.
|
||||
- `clear` forgets the current direct path and allows normal path discovery to repopulate it.
|
||||
- `flood` forces replies to use flood packets until the client logs in again.
|
||||
|
||||
---
|
||||
|
||||
#### Create a new region
|
||||
**Usage:**
|
||||
- `region put <name> [parent_name]`
|
||||
@@ -1021,6 +961,247 @@ region save
|
||||
- Enables flooding for all child regions automatically
|
||||
- Useful for global networks with specific regional rules
|
||||
|
||||
---
|
||||
### Direct Retry
|
||||
|
||||
Direct retry resends direct-routed packets when the downstream echo is not heard. It applies to direct messages, ACK packets, multipart packets carrying ACK payloads, and TRACE packets.
|
||||
|
||||
#### View or change direct retry state
|
||||
**Usage:**
|
||||
- `get direct.retry`
|
||||
- `set direct.retry <state>`
|
||||
|
||||
**Parameters:**
|
||||
- `state`: `on`|`off`
|
||||
|
||||
**Default:** `on`
|
||||
|
||||
**Notes:**
|
||||
- New installs and older preference files without direct retry settings default to `on` with the `rooftop` preset.
|
||||
|
||||
**Examples:**
|
||||
```
|
||||
get direct.retry
|
||||
set direct.retry on
|
||||
set direct.retry off
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### View or apply a direct retry preset
|
||||
**Usage:**
|
||||
- `get retry.preset`
|
||||
- `set retry.preset <preset>`
|
||||
|
||||
**Parameters:**
|
||||
- `preset`: `infra`|`rooftop`|`mobile`
|
||||
|
||||
**Notes:**
|
||||
- `infra`: fewer, slower retries for stable fixed infrastructure.
|
||||
- `rooftop`: default long retry window for weak rooftop links.
|
||||
- `mobile`: long retry count with shorter spacing for moving or changing links.
|
||||
- Changing `direct.retry.count`, `direct.retry.base`, `direct.retry.step`, or `direct.retry.margin` makes the preset report as `custom`.
|
||||
|
||||
**Examples:**
|
||||
```
|
||||
get retry.preset
|
||||
set retry.preset infra
|
||||
set retry.preset rooftop
|
||||
set retry.preset mobile
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### View or change direct retry count
|
||||
**Usage:**
|
||||
- `get direct.retry.count`
|
||||
- `set direct.retry.count <count>`
|
||||
|
||||
**Parameters:**
|
||||
- `count`: Maximum retry attempts after the original send, from `1` to `15`.
|
||||
|
||||
**Default:** `15` with the `rooftop` preset
|
||||
|
||||
**Examples:**
|
||||
```
|
||||
get direct.retry.count
|
||||
set direct.retry.count 1
|
||||
set direct.retry.count 4
|
||||
set direct.retry.count 15
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### View or change direct retry base delay
|
||||
**Usage:**
|
||||
- `get direct.retry.base`
|
||||
- `set direct.retry.base <ms>`
|
||||
|
||||
**Parameters:**
|
||||
- `ms`: First retry wait in milliseconds, from `10` to `5000`.
|
||||
|
||||
**Default:** `175` with the `rooftop` preset
|
||||
|
||||
**Explanation:**
|
||||
- The first retry waits `base` milliseconds after the failed echo window.
|
||||
- Larger values reduce channel pressure and give slow repeaters more time.
|
||||
- Smaller values recover faster but create tighter retry bursts.
|
||||
|
||||
**Examples:**
|
||||
```
|
||||
get direct.retry.base
|
||||
set direct.retry.base 175
|
||||
set direct.retry.base 275
|
||||
set direct.retry.base 500
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### View or change direct retry step delay
|
||||
**Usage:**
|
||||
- `get direct.retry.step`
|
||||
- `set direct.retry.step <ms>`
|
||||
|
||||
**Parameters:**
|
||||
- `ms`: Extra milliseconds added for each subsequent retry, from `0` to `5000`.
|
||||
|
||||
**Default:** `100` with the `rooftop` preset
|
||||
|
||||
**Explanation:**
|
||||
- Retry delay is `base + attempt_index * step`.
|
||||
- With `base=175` and `step=100`, retries wait about `175`, `275`, `375`, `475` ms, and so on.
|
||||
- `step=0` keeps every retry at the same delay.
|
||||
- Larger steps spread retries over time and are safer on busy channels.
|
||||
|
||||
**Examples:**
|
||||
```
|
||||
get direct.retry.step
|
||||
set direct.retry.step 0
|
||||
set direct.retry.step 50
|
||||
set direct.retry.step 100
|
||||
set direct.retry.step 250
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### View or change direct retry SNR margin
|
||||
**Usage:**
|
||||
- `get direct.retry.margin`
|
||||
- `set direct.retry.margin <snr_db>`
|
||||
|
||||
**Parameters:**
|
||||
- `snr_db`: Extra SNR margin above the SF receive floor, from `0` to `40`.
|
||||
|
||||
**Default:** `5.00` with the `rooftop` preset
|
||||
|
||||
**Notes:**
|
||||
- Unknown repeaters are still retried.
|
||||
- Known repeaters below the receive floor plus this margin are skipped.
|
||||
- Failed attempts lower the recent repeater SNR estimate by `0.25 dB`.
|
||||
|
||||
**Examples:**
|
||||
```
|
||||
get direct.retry.margin
|
||||
set direct.retry.margin 0
|
||||
set direct.retry.margin 2.5
|
||||
set direct.retry.margin 5
|
||||
set direct.retry.margin 10
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### View or change adaptive direct retry coding rate
|
||||
**Usage:**
|
||||
- `get direct.retry.cr`
|
||||
- `set direct.retry.cr off`
|
||||
- `set direct.retry.cr <cr4_min>,<cr5_min>,<cr7_min>,<cr8_max>`
|
||||
|
||||
**Parameters:**
|
||||
- `cr4_min`: Minimum SNR in dB to retry at CR4.
|
||||
- `cr5_min`: Minimum SNR in dB to retry at CR5.
|
||||
- `cr7_min`: Minimum SNR in dB to retry at CR7.
|
||||
- `cr8_max`: Maximum SNR in dB that forces CR8.
|
||||
|
||||
**Default:** `10.00,7.50,2.50,2.50`
|
||||
|
||||
**Explanation:**
|
||||
- Higher SNR uses faster coding rates.
|
||||
- Lower SNR uses more robust coding rates.
|
||||
- CR6 is intentionally skipped.
|
||||
- `off` disables per-packet retry CR overrides and uses the current radio CR.
|
||||
- Direct path retry packets sent at CR4 or CR5 temporarily use a shorter 16-symbol preamble, then restore the radio's default preamble.
|
||||
- Unknown repeaters start at `+3.00 dB` for adaptive CR selection.
|
||||
- A failed unknown repeater is seeded at `+2.75 dB`.
|
||||
- Each later failure lowers the SNR estimate by `0.25 dB`.
|
||||
|
||||
**Examples:**
|
||||
```
|
||||
get direct.retry.cr
|
||||
set direct.retry.cr off
|
||||
set direct.retry.cr 10.0,7.5,2.5,2.5
|
||||
set direct.retry.cr 12.0,8.0,4.0,1.0
|
||||
set direct.retry.cr 8.0,5.0,1.5,0
|
||||
set direct.retry.cr 6.0,3.0,0,-2.0
|
||||
set direct.retry.cr 20.0,12.0,6.0,2.0
|
||||
set direct.retry.cr 4.0,2.0,0,-4.0
|
||||
```
|
||||
|
||||
**Example profiles:**
|
||||
- Conservative weak-link profile:
|
||||
```
|
||||
set direct.retry.cr 12.0,8.0,4.0,1.0
|
||||
```
|
||||
- Balanced rooftop profile:
|
||||
```
|
||||
set direct.retry.cr 10.0,7.5,2.5,2.5
|
||||
```
|
||||
- Faster strong-link profile:
|
||||
```
|
||||
set direct.retry.cr 6.0,3.0,0,-2.0
|
||||
```
|
||||
- Very cautious noisy-link profile:
|
||||
```
|
||||
set direct.retry.cr 20.0,12.0,6.0,2.0
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### View, seed, or clear the recent repeater table
|
||||
**Usage:**
|
||||
- `get recent.repeater`
|
||||
- `get recent.repeater <page>`
|
||||
- `set recent.repeater <prefix> [snr_db]`
|
||||
- `clear recent.repeater`
|
||||
|
||||
**Parameters:**
|
||||
- `prefix`: Repeater path-hash prefix as hex.
|
||||
- `snr_db`: Optional SNR in dB. If omitted or invalid, defaults to `3.0`.
|
||||
- `page`: 1-based result page.
|
||||
|
||||
**Output order:**
|
||||
- `get recent.repeater` lists 3-byte prefixes first, then 2-byte prefixes, then 1-byte prefixes.
|
||||
- Within each prefix length, entries are sorted from highest SNR to lowest SNR.
|
||||
|
||||
**SNR details:**
|
||||
- Recent repeater SNR is stored internally in quarter-dB units.
|
||||
- Heard repeater samples update an existing table entry with a weighted blend: `75%` existing SNR and `25%` new heard SNR, rounded up.
|
||||
- Direct retry success also feeds the heard echo SNR back into the same weighted table.
|
||||
- Direct retry failure is not weighted: each final echo-timeout failure lowers that repeater's SNR by `0.25 dB`.
|
||||
- Unknown repeaters start at `+3.00 dB` for adaptive CR selection.
|
||||
- If an unknown repeater fails, it is seeded into the table at `+2.75 dB`.
|
||||
- `set recent.repeater <prefix> [snr_db]` seeds a missing prefix or adds another weighted sample for an existing prefix.
|
||||
- Successful `set recent.repeater` replies include the stored prefix and SNR, for example `OK - set A1B2C3 at 3.0 SNR`.
|
||||
|
||||
**Examples:**
|
||||
```
|
||||
get recent.repeater
|
||||
get recent.repeater 2
|
||||
set recent.repeater A1B2C3 8.5
|
||||
set recent.repeater 71CE82 -3.25
|
||||
set recent.repeater A1B2C3
|
||||
clear recent.repeater
|
||||
```
|
||||
|
||||
---
|
||||
### GPS (When GPS support is compiled in)
|
||||
|
||||
|
||||
@@ -549,6 +549,203 @@ uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {
|
||||
return getRNG()->nextInt(0, 5*t + 1);
|
||||
}
|
||||
|
||||
bool MyMesh::extractDirectRetryPrefix(const mesh::Packet* packet, uint8_t* prefix, uint8_t& prefix_len) const {
|
||||
if (packet == NULL || !packet->isRouteDirect() || packet->getPathHashCount() == 0) {
|
||||
return false;
|
||||
}
|
||||
prefix_len = packet->getPathHashSize();
|
||||
memcpy(prefix, packet->path, prefix_len);
|
||||
return true;
|
||||
}
|
||||
|
||||
int8_t MyMesh::getDirectRetryMinSNRX4() const {
|
||||
switch (active_sf) {
|
||||
case 7: return -30;
|
||||
case 8: return -40;
|
||||
case 9: return -50;
|
||||
case 10: return -60;
|
||||
case 11: return -70;
|
||||
case 12: return -80;
|
||||
default: return -60;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t MyMesh::getDirectRetryCodingRateForSNR(int8_t snr_x4) const {
|
||||
if (!_prefs.direct_retry_cr_enabled) return 0;
|
||||
if (snr_x4 >= _prefs.direct_retry_cr4_snr_x4) return 4;
|
||||
if (snr_x4 >= _prefs.direct_retry_cr5_snr_x4) return 5;
|
||||
if (snr_x4 <= _prefs.direct_retry_cr8_snr_x4) return 8;
|
||||
if (snr_x4 >= _prefs.direct_retry_cr7_snr_x4) return 7;
|
||||
return 7;
|
||||
}
|
||||
|
||||
uint8_t MyMesh::getDirectRetryConfiguredMaxAttempts() const {
|
||||
return constrain(_prefs.direct_retry_attempts, 1, 15);
|
||||
}
|
||||
|
||||
uint32_t MyMesh::getDirectRetryAttemptStepMillis() const {
|
||||
return _prefs.direct_retry_step_ms;
|
||||
}
|
||||
|
||||
bool MyMesh::allowDirectRetry(const mesh::Packet* packet, const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) const {
|
||||
(void)packet;
|
||||
if (!_prefs.direct_retry_enabled) {
|
||||
return false;
|
||||
}
|
||||
if (next_hop_hash == NULL || next_hop_hash_len == 0) {
|
||||
return true;
|
||||
}
|
||||
const SimpleMeshTables* tables = static_cast<const SimpleMeshTables*>(getTables());
|
||||
const SimpleMeshTables::RecentRepeaterInfo* repeater = tables != NULL
|
||||
? tables->findRecentRepeaterByHash(next_hop_hash, next_hop_hash_len)
|
||||
: NULL;
|
||||
|
||||
if (repeater == NULL) {
|
||||
// Retry unknown repeaters too. If they fail, onDirectRetryFailed() seeds the
|
||||
// recent-repeater table below the +3.00 dB starting point.
|
||||
return true;
|
||||
}
|
||||
int16_t retry_floor_x4 = (int16_t)getDirectRetryMinSNRX4() + (int16_t)_prefs.direct_retry_snr_margin_x4;
|
||||
return (int16_t)repeater->snr_x4 >= retry_floor_x4;
|
||||
}
|
||||
|
||||
void MyMesh::configureDirectRetryPacket(mesh::Packet* retry, const mesh::Packet* original, uint8_t retry_attempt) {
|
||||
(void)retry_attempt;
|
||||
int8_t snr_x4 = 12; // unknown repeaters start at +3.00 dB
|
||||
const SimpleMeshTables* tables = static_cast<const SimpleMeshTables*>(getTables());
|
||||
if (tables != NULL) {
|
||||
uint8_t prefix[MAX_HASH_SIZE];
|
||||
uint8_t prefix_len = 0;
|
||||
if (extractDirectRetryPrefix(original, prefix, prefix_len)) {
|
||||
const SimpleMeshTables::RecentRepeaterInfo* repeater = tables->findRecentRepeaterByHash(prefix, prefix_len);
|
||||
if (repeater != NULL) {
|
||||
snr_x4 = repeater->snr_x4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
retry->tx_cr = getDirectRetryCodingRateForSNR(snr_x4);
|
||||
}
|
||||
|
||||
uint32_t MyMesh::getDirectRetryEchoDelay(const mesh::Packet* packet) const {
|
||||
(void)packet;
|
||||
return 200;
|
||||
}
|
||||
|
||||
uint8_t MyMesh::getDirectRetryMaxAttempts(const mesh::Packet* packet) const {
|
||||
(void)packet;
|
||||
return getDirectRetryConfiguredMaxAttempts();
|
||||
}
|
||||
|
||||
uint32_t MyMesh::getDirectRetryAttemptDelay(const mesh::Packet* packet, uint8_t attempt_idx) {
|
||||
(void)packet;
|
||||
return _prefs.direct_retry_base_ms + ((uint32_t)attempt_idx * getDirectRetryAttemptStepMillis());
|
||||
}
|
||||
|
||||
void MyMesh::onDirectRetryEvent(const char* event, const mesh::Packet* packet, uint32_t delay_millis, uint8_t retry_attempt) {
|
||||
#if MESH_DEBUG
|
||||
MESH_DEBUG_PRINTLN("direct retry %s attempt=%u delay=%lu type=%u route=%s",
|
||||
event ? event : "?",
|
||||
(uint32_t)retry_attempt,
|
||||
(unsigned long)delay_millis,
|
||||
packet ? (uint32_t)packet->getPayloadType() : 0,
|
||||
packet && packet->isRouteDirect() ? "D" : "F");
|
||||
#endif
|
||||
if (_logging) {
|
||||
File f = openAppend(PACKET_LOG_FILE);
|
||||
if (f) {
|
||||
f.print(getLogDateTime());
|
||||
f.printf(": direct retry %s attempt=%u delay=%lu type=%u route=%s\n",
|
||||
event ? event : "?",
|
||||
(uint32_t)retry_attempt,
|
||||
(unsigned long)delay_millis,
|
||||
packet ? (uint32_t)packet->getPayloadType() : 0,
|
||||
packet && packet->isRouteDirect() ? "D" : "F");
|
||||
f.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MyMesh::onDirectRetryFailed(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) {
|
||||
if (next_hop_hash == NULL || next_hop_hash_len == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
SimpleMeshTables* tables = static_cast<SimpleMeshTables*>(getTables());
|
||||
if (tables != NULL) {
|
||||
if (!tables->decrementRecentRepeaterSnrX4(next_hop_hash, next_hop_hash_len, 1)) {
|
||||
tables->setRecentRepeater(next_hop_hash, next_hop_hash_len, 11);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MyMesh::onDirectRetrySucceeded(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len, int8_t snr_x4) {
|
||||
if (next_hop_hash == NULL || next_hop_hash_len == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
SimpleMeshTables* tables = static_cast<SimpleMeshTables*>(getTables());
|
||||
if (tables != NULL) {
|
||||
tables->setRecentRepeater(next_hop_hash, next_hop_hash_len, snr_x4);
|
||||
}
|
||||
}
|
||||
|
||||
static void formatLocalSnrX4(char* dest, size_t dest_len, int16_t snr_x4) {
|
||||
int16_t v = snr_x4;
|
||||
const char* sign = "";
|
||||
if (v < 0) {
|
||||
sign = "-";
|
||||
v = -v;
|
||||
}
|
||||
snprintf(dest, dest_len, "%s%d.%02d", sign, v / 4, (v % 4) * 25);
|
||||
}
|
||||
|
||||
void MyMesh::formatRecentRepeatersReply(char *reply, int page) {
|
||||
const SimpleMeshTables* tables = static_cast<const SimpleMeshTables*>(getTables());
|
||||
if (tables == NULL) {
|
||||
strcpy(reply, "Error: unsupported");
|
||||
return;
|
||||
}
|
||||
int count = tables->getRecentRepeaterCount();
|
||||
if (count <= 0) {
|
||||
strcpy(reply, "> -none-");
|
||||
return;
|
||||
}
|
||||
|
||||
const int page_size = 4;
|
||||
int pages = (count + page_size - 1) / page_size;
|
||||
if (page < 1) page = 1;
|
||||
if (page > pages) page = pages;
|
||||
|
||||
int len = snprintf(reply, 160, "> %d/%d ", page, pages);
|
||||
int start = (page - 1) * page_size;
|
||||
for (int i = 0; i < page_size && len < 150; i++) {
|
||||
const SimpleMeshTables::RecentRepeaterInfo* info = tables->getRecentRepeaterBySortedIdx(start + i);
|
||||
if (info == NULL) break;
|
||||
char prefix[MAX_ROUTE_HASH_BYTES * 2 + 1];
|
||||
char snr[12];
|
||||
mesh::Utils::toHex(prefix, info->prefix, info->prefix_len);
|
||||
prefix[info->prefix_len * 2] = 0;
|
||||
formatLocalSnrX4(snr, sizeof(snr), info->snr_x4);
|
||||
len += snprintf(&reply[len], 160 - len, "%s%s,%s",
|
||||
i == 0 ? "" : " ",
|
||||
prefix,
|
||||
snr);
|
||||
}
|
||||
}
|
||||
|
||||
bool MyMesh::setRecentRepeater(const uint8_t* prefix, uint8_t prefix_len, int8_t snr_x4) {
|
||||
SimpleMeshTables* tables = static_cast<SimpleMeshTables*>(getTables());
|
||||
return tables != NULL && tables->setRecentRepeater(prefix, prefix_len, snr_x4);
|
||||
}
|
||||
|
||||
void MyMesh::clearRecentRepeaters() {
|
||||
SimpleMeshTables* tables = static_cast<SimpleMeshTables*>(getTables());
|
||||
if (tables != NULL) {
|
||||
tables->clearRecentRepeaters();
|
||||
}
|
||||
}
|
||||
|
||||
bool MyMesh::filterRecvFloodPacket(mesh::Packet* pkt) {
|
||||
// just try to determine region for packet (apply later in allowPacketForward())
|
||||
if (pkt->getRouteType() == ROUTE_TYPE_TRANSPORT_FLOOD) {
|
||||
@@ -867,6 +1064,8 @@ MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondCloc
|
||||
next_local_advert = next_flood_advert = 0;
|
||||
dirty_contacts_expiry = 0;
|
||||
set_radio_at = revert_radio_at = 0;
|
||||
active_sf = 0;
|
||||
active_cr = 0;
|
||||
_logging = false;
|
||||
region_load_active = false;
|
||||
|
||||
@@ -896,6 +1095,19 @@ MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondCloc
|
||||
_prefs.flood_max_advert = 8;
|
||||
_prefs.interference_threshold = 0; // disabled
|
||||
_prefs.cad_enabled = 0; // hardware CAD before TX (off by default; 'set cad on')
|
||||
_prefs.retry_preset = RETRY_PRESET_ROOFTOP;
|
||||
_prefs.direct_retry_attempts = DIRECT_RETRY_ROOFTOP_COUNT;
|
||||
_prefs.direct_retry_base_ms = DIRECT_RETRY_ROOFTOP_BASE_MS;
|
||||
_prefs.direct_retry_step_ms = DIRECT_RETRY_ROOFTOP_STEP_MS;
|
||||
_prefs.direct_retry_snr_margin_x4 = DIRECT_RETRY_ROOFTOP_MARGIN_X4;
|
||||
_prefs.direct_retry_cr4_snr_x4 = DIRECT_RETRY_CR4_MIN_SNR_X4_DEFAULT;
|
||||
_prefs.direct_retry_cr5_snr_x4 = DIRECT_RETRY_CR5_MIN_SNR_X4_DEFAULT;
|
||||
_prefs.direct_retry_cr7_snr_x4 = DIRECT_RETRY_CR7_MIN_SNR_X4_DEFAULT;
|
||||
_prefs.direct_retry_cr8_snr_x4 = DIRECT_RETRY_CR8_MAX_SNR_X4_DEFAULT;
|
||||
_prefs.direct_retry_enabled = 1;
|
||||
_prefs.direct_retry_cr_enabled = 1;
|
||||
_prefs.direct_retry_prefs_magic[0] = DIRECT_RETRY_PREFS_MAGIC_0;
|
||||
_prefs.direct_retry_prefs_magic[1] = DIRECT_RETRY_PREFS_MAGIC_1;
|
||||
|
||||
// bridge defaults
|
||||
_prefs.bridge_enabled = 1; // enabled
|
||||
@@ -964,6 +1176,8 @@ void MyMesh::begin(FILESYSTEM *fs) {
|
||||
#endif
|
||||
|
||||
radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
|
||||
active_sf = _prefs.sf;
|
||||
active_cr = _prefs.cr;
|
||||
radio_driver.setTxPower(_prefs.tx_power_dbm);
|
||||
|
||||
radio_driver.setRxBoostedGainMode(_prefs.rx_boosted_gain);
|
||||
@@ -1420,12 +1634,16 @@ void MyMesh::loop() {
|
||||
if (set_radio_at && millisHasNowPassed(set_radio_at)) { // apply pending (temporary) radio params
|
||||
set_radio_at = 0; // clear timer
|
||||
radio_driver.setParams(pending_freq, pending_bw, pending_sf, pending_cr);
|
||||
active_sf = pending_sf;
|
||||
active_cr = pending_cr;
|
||||
MESH_DEBUG_PRINTLN("Temp radio params");
|
||||
}
|
||||
|
||||
if (revert_radio_at && millisHasNowPassed(revert_radio_at)) { // revert radio params to orig
|
||||
revert_radio_at = 0; // clear timer
|
||||
radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
|
||||
active_sf = _prefs.sf;
|
||||
active_cr = _prefs.cr;
|
||||
MESH_DEBUG_PRINTLN("Radio params restored");
|
||||
}
|
||||
|
||||
|
||||
@@ -85,9 +85,6 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
|
||||
uint32_t last_millis;
|
||||
uint64_t uptime_millis;
|
||||
unsigned long next_local_advert, next_flood_advert;
|
||||
unsigned long next_battery_alert_check;
|
||||
unsigned long last_battery_alert_sent;
|
||||
bool battery_alert_sent;
|
||||
bool _logging;
|
||||
NodePrefs _prefs;
|
||||
ClientACL acl;
|
||||
@@ -102,15 +99,6 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
|
||||
RegionEntry* recv_pkt_region;
|
||||
TransportKey default_scope;
|
||||
RateLimiter discover_limiter, anon_limiter;
|
||||
struct FloodRetryBridgeState {
|
||||
uint8_t key[MAX_HASH_SIZE];
|
||||
uint8_t source_bucket;
|
||||
uint8_t target_mask;
|
||||
uint8_t heard_mask;
|
||||
uint8_t progress_marker;
|
||||
bool active;
|
||||
};
|
||||
mutable FloodRetryBridgeState flood_retry_bridge_states[MAX_FLOOD_RETRY_SLOTS];
|
||||
uint32_t pending_discover_tag;
|
||||
unsigned long pending_discover_until;
|
||||
bool region_load_active;
|
||||
@@ -122,7 +110,6 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
|
||||
unsigned long set_radio_at, revert_radio_at;
|
||||
float pending_freq;
|
||||
float pending_bw;
|
||||
float active_bw; // live BW, including temporary radio overrides
|
||||
uint8_t pending_sf;
|
||||
uint8_t active_sf; // live SF, including temporary radio overrides
|
||||
uint8_t pending_cr;
|
||||
@@ -137,28 +124,8 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
|
||||
bool extractDirectRetryPrefix(const mesh::Packet* packet, uint8_t* prefix, uint8_t& prefix_len) const;
|
||||
int8_t getDirectRetryMinSNRX4() const;
|
||||
uint8_t getDirectRetryCodingRateForSNR(int8_t snr_x4) const;
|
||||
uint8_t getDirectRetryPreset() const;
|
||||
uint8_t getDirectRetryConfiguredMaxAttempts() const;
|
||||
uint32_t getDirectRetryAttemptStepMillis() const;
|
||||
bool hasFloodRetryPrefixes() const;
|
||||
bool floodRetryPrefixMatches(const mesh::Packet* packet) const;
|
||||
bool floodRetryLastHopMatches(const mesh::Packet* packet) const;
|
||||
bool floodRetryPrefixIgnored(const uint8_t* prefix, uint8_t prefix_len) const;
|
||||
uint8_t floodRetryEffectivePathLength(const mesh::Packet* packet, uint8_t max_hops = 0xFF) const;
|
||||
bool floodRetryPrefixFresh(const uint8_t* prefix, uint8_t prefix_len) const;
|
||||
int floodRetryBucketForPrefix(const uint8_t* prefix, uint8_t prefix_len, bool require_fresh,
|
||||
bool include_other) const;
|
||||
int floodRetryBucketForPathHop(const uint8_t* prefix, uint8_t prefix_len, uint8_t hop,
|
||||
uint8_t progress_marker) const;
|
||||
int floodRetrySourceBucket(const mesh::Packet* packet) const;
|
||||
uint8_t floodRetryBridgeTargetMask(uint8_t source_bucket) const;
|
||||
uint8_t floodRetryBridgeHeardMask(const mesh::Packet* packet, uint8_t source_bucket,
|
||||
uint8_t progress_marker) const;
|
||||
FloodRetryBridgeState* floodRetryBridgeStateFor(const mesh::Packet* packet, bool create) const;
|
||||
void clearFloodRetryBridgeState(const mesh::Packet* packet);
|
||||
void refreshFloodRetryHeardRecent(const mesh::Packet* packet);
|
||||
void formatFloodRetryPath(char* dest, size_t dest_len, const mesh::Packet* packet) const;
|
||||
bool formatFloodRetryHeard(char* dest, size_t dest_len, const mesh::Packet* packet) const;
|
||||
void putNeighbour(const mesh::Identity& id, uint32_t timestamp, float snr);
|
||||
uint8_t handleLoginReq(const mesh::Identity& sender, const uint8_t* secret, uint32_t sender_timestamp, const uint8_t* data, bool is_flood);
|
||||
uint8_t handleAnonRegionsReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data);
|
||||
@@ -166,8 +133,6 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
|
||||
uint8_t handleAnonClockReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data);
|
||||
int handleRequest(ClientInfo* sender, uint32_t sender_timestamp, uint8_t* payload, size_t payload_len);
|
||||
mesh::Packet* createSelfAdvert();
|
||||
bool sendRepeatersFloodText(const char* text);
|
||||
void checkBatteryAlert();
|
||||
|
||||
File openAppend(const char* fname);
|
||||
bool isLooped(const mesh::Packet* packet, const uint8_t max_counters[]);
|
||||
@@ -190,18 +155,13 @@ protected:
|
||||
uint32_t getDirectRetransmitDelay(const mesh::Packet* packet) override;
|
||||
uint8_t getDefaultTxCodingRate() const override { return active_cr; }
|
||||
bool allowDirectRetry(const mesh::Packet* packet, const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) const override;
|
||||
bool maybeShortCircuitDirect(mesh::Packet* packet) override;
|
||||
void configureDirectRetryPacket(mesh::Packet* retry, const mesh::Packet* original, uint8_t retry_attempt) override;
|
||||
uint32_t getDirectRetryEchoDelay(const mesh::Packet* packet) const override;
|
||||
uint8_t getDirectRetryMaxAttempts(const mesh::Packet* packet) const override;
|
||||
uint32_t getDirectRetryAttemptDelay(const mesh::Packet* packet, uint8_t attempt_idx) override;
|
||||
void onDirectRetryEvent(const char* event, const mesh::Packet* packet, uint32_t delay_millis, uint8_t retry_attempt) override;
|
||||
bool allowFloodRetry(const mesh::Packet* packet) const override;
|
||||
void onFloodRetryEvent(const char* event, const mesh::Packet* packet, uint32_t delay_millis, uint8_t retry_attempt) override;
|
||||
bool hasFloodRetryTargetPrefix(const mesh::Packet* packet) const override;
|
||||
uint8_t getFloodRetryMaxPathLength(const mesh::Packet* packet) const override;
|
||||
uint8_t getFloodRetryMaxAttempts(const mesh::Packet* packet) const override;
|
||||
bool isFloodRetryEchoTarget(const mesh::Packet* packet, uint8_t progress_marker) const override;
|
||||
void onDirectRetryFailed(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) override;
|
||||
void onDirectRetrySucceeded(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len, int8_t snr_x4) override;
|
||||
|
||||
int getInterferenceThreshold() const override {
|
||||
return _prefs.interference_threshold;
|
||||
@@ -233,20 +193,6 @@ protected:
|
||||
void onControlDataRecv(mesh::Packet* packet) override;
|
||||
|
||||
void sendFloodReply(mesh::Packet* packet, unsigned long delay_millis, uint8_t path_hash_size);
|
||||
mesh::Packet* createPacketCopy(const mesh::Packet* packet, const char* caller);
|
||||
mesh::Packet* createAltPathCopy(const mesh::Packet* packet,
|
||||
const uint8_t* primary_path, uint8_t primary_path_len,
|
||||
const uint8_t* alt_path, uint8_t alt_path_len);
|
||||
void sendFloodReplyWithAltPath(mesh::Packet* packet,
|
||||
const uint8_t* direct_path, uint8_t direct_path_len,
|
||||
const uint8_t* alt_path, uint8_t alt_path_len,
|
||||
unsigned long delay_millis, uint8_t path_hash_size);
|
||||
void sendDirectWithAltPath(mesh::Packet* packet,
|
||||
const uint8_t* path, uint8_t path_len,
|
||||
const uint8_t* alt_path, uint8_t alt_path_len,
|
||||
uint32_t delay_millis);
|
||||
void sendFloodScopedWithSelfPath(const TransportKey& scope, mesh::Packet* pkt,
|
||||
uint32_t delay_millis, uint8_t path_hash_size);
|
||||
|
||||
public:
|
||||
MyMesh(mesh::MainBoard& board, mesh::Radio& radio, mesh::MillisecondClock& ms, mesh::RNG& rng, mesh::RTCClock& rtc, mesh::MeshTables& tables);
|
||||
@@ -287,6 +233,9 @@ public:
|
||||
void formatStatsReply(char *reply) override;
|
||||
void formatRadioStatsReply(char *reply) override;
|
||||
void formatPacketStatsReply(char *reply) override;
|
||||
void formatRecentRepeatersReply(char *reply, int page) override;
|
||||
bool setRecentRepeater(const uint8_t* prefix, uint8_t prefix_len, int8_t snr_x4) override;
|
||||
void clearRecentRepeaters() override;
|
||||
void startRegionsLoad() override;
|
||||
bool saveRegions() override;
|
||||
void onDefaultRegionChanged(const RegionEntry* r) override;
|
||||
|
||||
+23
-4
@@ -52,11 +52,15 @@ void Dispatcher::updateTxBudget() {
|
||||
}
|
||||
}
|
||||
|
||||
void Dispatcher::restoreOutboundCodingRate() {
|
||||
void Dispatcher::restoreOutboundTxOverrides() {
|
||||
if (outbound_restore_cr != 0) {
|
||||
_radio->setCodingRate(outbound_restore_cr);
|
||||
outbound_restore_cr = 0;
|
||||
}
|
||||
if (outbound_restore_preamble_len != 0) {
|
||||
_radio->setPreambleLength(outbound_restore_preamble_len);
|
||||
outbound_restore_preamble_len = 0;
|
||||
}
|
||||
}
|
||||
|
||||
int Dispatcher::calcRxDelay(float score, uint32_t air_time) const {
|
||||
@@ -113,7 +117,7 @@ void Dispatcher::loop() {
|
||||
}
|
||||
|
||||
_radio->onSendFinished();
|
||||
restoreOutboundCodingRate();
|
||||
restoreOutboundTxOverrides();
|
||||
logTx(outbound, 2 + outbound->getPathByteLen() + outbound->payload_len);
|
||||
onSendComplete(outbound);
|
||||
if (outbound->isRouteFlood()) {
|
||||
@@ -127,7 +131,7 @@ void Dispatcher::loop() {
|
||||
MESH_DEBUG_PRINTLN("%s Dispatcher::loop(): WARNING: outbound packed send timed out!", getLogDateTime());
|
||||
|
||||
_radio->onSendFinished();
|
||||
restoreOutboundCodingRate();
|
||||
restoreOutboundTxOverrides();
|
||||
logTxFail(outbound, 2 + outbound->getPathByteLen() + outbound->payload_len);
|
||||
onSendFail(outbound);
|
||||
|
||||
@@ -342,22 +346,37 @@ void Dispatcher::checkSend() {
|
||||
|
||||
uint32_t max_airtime = _radio->getEstAirtimeFor(len)*3/2;
|
||||
outbound_restore_cr = 0;
|
||||
outbound_restore_preamble_len = 0;
|
||||
uint8_t default_cr = getDefaultTxCodingRate();
|
||||
bool using_low_retry_cr = false;
|
||||
if (outbound->tx_cr >= 4 && outbound->tx_cr <= 8 && default_cr >= 4 && default_cr <= 8
|
||||
&& outbound->tx_cr != default_cr) {
|
||||
if (_radio->setCodingRate(outbound->tx_cr)) {
|
||||
outbound_restore_cr = default_cr;
|
||||
using_low_retry_cr = outbound->tx_cr == 4 || outbound->tx_cr == 5;
|
||||
max_airtime = _radio->getEstAirtimeFor(len)*3/2;
|
||||
} else {
|
||||
MESH_DEBUG_PRINTLN("%s Dispatcher::checkSend(): WARN: failed to set packet CR%d", getLogDateTime(), (uint32_t)outbound->tx_cr);
|
||||
}
|
||||
} else if (outbound->tx_cr == 4 || outbound->tx_cr == 5) {
|
||||
using_low_retry_cr = outbound->tx_cr == default_cr;
|
||||
}
|
||||
bool has_direct_path = outbound->getPathHashCount() > 0
|
||||
|| (outbound->getPayloadType() == PAYLOAD_TYPE_TRACE && outbound->payload_len > 9);
|
||||
if (outbound->isRouteDirect() && has_direct_path
|
||||
&& using_low_retry_cr) {
|
||||
uint16_t default_preamble_len = _radio->getDefaultPreambleLength();
|
||||
if (default_preamble_len > 16 && _radio->setPreambleLength(16)) {
|
||||
outbound_restore_preamble_len = default_preamble_len;
|
||||
max_airtime = _radio->getEstAirtimeFor(len)*3/2;
|
||||
}
|
||||
}
|
||||
outbound_start = _ms->getMillis();
|
||||
bool success = _radio->startSendRaw(raw, len);
|
||||
if (!success) {
|
||||
MESH_DEBUG_PRINTLN("%s Dispatcher::loop(): ERROR: send start failed!", getLogDateTime());
|
||||
|
||||
restoreOutboundCodingRate();
|
||||
restoreOutboundTxOverrides();
|
||||
logTxFail(outbound, outbound->getRawLength());
|
||||
onSendFail(outbound);
|
||||
|
||||
|
||||
+6
-3
@@ -51,6 +51,8 @@ public:
|
||||
* \returns true if the radio accepted the coding rate.
|
||||
*/
|
||||
virtual bool setCodingRate(uint8_t cr) { return false; }
|
||||
virtual uint16_t getDefaultPreambleLength() const { return 0; }
|
||||
virtual bool setPreambleLength(uint16_t len) { return false; }
|
||||
|
||||
/**
|
||||
* \returns true if the previous 'startSendRaw()' completed successfully.
|
||||
@@ -124,6 +126,7 @@ typedef uint32_t DispatcherAction;
|
||||
class Dispatcher {
|
||||
Packet* outbound; // current outbound packet
|
||||
unsigned long outbound_expiry, outbound_start, total_air_time, rx_air_time;
|
||||
uint16_t outbound_restore_preamble_len;
|
||||
uint8_t outbound_restore_cr;
|
||||
unsigned long next_tx_time;
|
||||
unsigned long cad_busy_start;
|
||||
@@ -137,7 +140,7 @@ class Dispatcher {
|
||||
unsigned long duty_cycle_window_ms;
|
||||
|
||||
void processRecvPacket(Packet* pkt);
|
||||
void restoreOutboundCodingRate();
|
||||
void restoreOutboundTxOverrides();
|
||||
void updateTxBudget();
|
||||
|
||||
protected:
|
||||
@@ -150,6 +153,7 @@ protected:
|
||||
: _radio(&radio), _ms(&ms), _mgr(&mgr)
|
||||
{
|
||||
outbound = NULL;
|
||||
outbound_restore_preamble_len = 0;
|
||||
outbound_restore_cr = 0;
|
||||
total_air_time = rx_air_time = 0;
|
||||
next_tx_time = ms.getMillis();
|
||||
@@ -210,9 +214,8 @@ public:
|
||||
bool millisHasNowPassed(unsigned long timestamp) const;
|
||||
unsigned long futureMillis(int millis_from_now) const;
|
||||
|
||||
bool tryParsePacket(Packet* pkt, const uint8_t* raw, int len);
|
||||
|
||||
private:
|
||||
bool tryParsePacket(Packet* pkt, const uint8_t* raw, int len);
|
||||
void checkRecv();
|
||||
void checkSend();
|
||||
};
|
||||
|
||||
+30
-19
@@ -37,6 +37,8 @@ void Mesh::begin() {
|
||||
_direct_retries[i].retry_at = 0;
|
||||
_direct_retries[i].retry_delay = 0;
|
||||
_direct_retries[i].retry_attempts_sent = 0;
|
||||
memset(_direct_retries[i].next_hop_hash, 0, sizeof(_direct_retries[i].next_hop_hash));
|
||||
_direct_retries[i].next_hop_hash_len = 0;
|
||||
_direct_retries[i].priority = 0;
|
||||
_direct_retries[i].progress_marker = 0;
|
||||
_direct_retries[i].expect_path_growth = false;
|
||||
@@ -78,6 +80,7 @@ void Mesh::loop() {
|
||||
: (uint32_t)(_ms->getMillis() - _direct_retries[i].retry_started_at);
|
||||
onDirectRetryEvent("failed_all_tries", _direct_retries[i].packet, elapsed_millis, _direct_retries[i].retry_attempts_sent);
|
||||
onDirectRetryEvent("failure", _direct_retries[i].packet, elapsed_millis, _direct_retries[i].retry_attempts_sent);
|
||||
onDirectRetryFailed(_direct_retries[i].next_hop_hash, _direct_retries[i].next_hop_hash_len);
|
||||
clearDirectRetrySlot(i);
|
||||
continue;
|
||||
}
|
||||
@@ -577,9 +580,6 @@ void Mesh::routeDirectRecvAcks(Packet* packet, uint32_t delay_millis) {
|
||||
}
|
||||
|
||||
void Mesh::clearDirectRetrySlot(int idx) {
|
||||
if (_direct_retries[idx].waiting_final_echo && _direct_retries[idx].packet != NULL) {
|
||||
releasePacket(_direct_retries[idx].packet);
|
||||
}
|
||||
_direct_retries[idx].packet = NULL;
|
||||
_direct_retries[idx].trigger_packet = NULL;
|
||||
_direct_retries[idx].retry_started_at = 0;
|
||||
@@ -587,6 +587,8 @@ void Mesh::clearDirectRetrySlot(int idx) {
|
||||
_direct_retries[idx].retry_at = 0;
|
||||
_direct_retries[idx].retry_delay = 0;
|
||||
_direct_retries[idx].retry_attempts_sent = 0;
|
||||
memset(_direct_retries[idx].next_hop_hash, 0, sizeof(_direct_retries[idx].next_hop_hash));
|
||||
_direct_retries[idx].next_hop_hash_len = 0;
|
||||
_direct_retries[idx].priority = 0;
|
||||
_direct_retries[idx].progress_marker = 0;
|
||||
_direct_retries[idx].expect_path_growth = false;
|
||||
@@ -627,6 +629,7 @@ bool Mesh::cancelDirectRetryOnEcho(const Packet* packet) {
|
||||
}
|
||||
|
||||
int8_t echo_snr_x4 = packet->_snr;
|
||||
onDirectRetrySucceeded(_direct_retries[i].next_hop_hash, _direct_retries[i].next_hop_hash_len, echo_snr_x4);
|
||||
if (_direct_retries[i].queued || _direct_retries[i].waiting_final_echo) {
|
||||
if (_direct_retries[i].packet != NULL) {
|
||||
// Success quality comes from the received downstream echo, not the original upstream RX.
|
||||
@@ -689,16 +692,9 @@ void Mesh::armDirectRetryOnSendComplete(const Packet* packet) {
|
||||
max_attempts = DIRECT_RETRY_MAX_ATTEMPTS_HARD_MAX;
|
||||
}
|
||||
if (_direct_retries[i].retry_attempts_sent >= max_attempts) {
|
||||
Packet* final_wait = obtainNewPacket();
|
||||
if (final_wait == NULL) {
|
||||
onDirectRetryEvent("dropped_no_packet", packet, elapsed_millis, _direct_retries[i].retry_attempts_sent);
|
||||
onDirectRetryEvent("failure", packet, elapsed_millis, _direct_retries[i].retry_attempts_sent);
|
||||
clearDirectRetrySlot(i);
|
||||
continue;
|
||||
}
|
||||
|
||||
*final_wait = *packet;
|
||||
_direct_retries[i].packet = final_wait;
|
||||
// Dispatcher releases the retry packet after this hook. Keep only retry metadata
|
||||
// for the final echo window so pool exhaustion cannot force a premature failure.
|
||||
_direct_retries[i].packet = NULL;
|
||||
_direct_retries[i].retry_at = futureMillis(_direct_retries[i].retry_delay);
|
||||
_direct_retries[i].waiting_final_echo = true;
|
||||
_direct_retries[i].queued = false;
|
||||
@@ -941,6 +937,9 @@ void Mesh::maybeScheduleDirectRetry(const Packet* packet, uint8_t priority) {
|
||||
_direct_retries[slot_idx].retry_at = 0;
|
||||
_direct_retries[slot_idx].retry_delay = retry_delay;
|
||||
_direct_retries[slot_idx].retry_attempts_sent = 0;
|
||||
memset(_direct_retries[slot_idx].next_hop_hash, 0, sizeof(_direct_retries[slot_idx].next_hop_hash));
|
||||
memcpy(_direct_retries[slot_idx].next_hop_hash, next_hop_hash, next_hop_hash_len);
|
||||
_direct_retries[slot_idx].next_hop_hash_len = next_hop_hash_len;
|
||||
_direct_retries[slot_idx].priority = priority;
|
||||
_direct_retries[slot_idx].progress_marker = progress_marker;
|
||||
_direct_retries[slot_idx].expect_path_growth = expect_path_growth;
|
||||
@@ -1341,7 +1340,9 @@ Packet* Mesh::createGroupDatagram(uint8_t type, const GroupChannel& channel, con
|
||||
return packet;
|
||||
}
|
||||
|
||||
Packet* Mesh::createAck(const uint8_t* ack, uint8_t len) {
|
||||
Packet* Mesh::createAck(const uint8_t* ack_hash, uint8_t ack_len) {
|
||||
if (ack_len > sizeof(Packet::payload)) return NULL;
|
||||
|
||||
Packet* packet = obtainNewPacket();
|
||||
if (packet == NULL) {
|
||||
MESH_DEBUG_PRINTLN("%s Mesh::createAck(): error, packet pool empty", getLogDateTime());
|
||||
@@ -1349,13 +1350,19 @@ Packet* Mesh::createAck(const uint8_t* ack, uint8_t len) {
|
||||
}
|
||||
packet->header = (PAYLOAD_TYPE_ACK << PH_TYPE_SHIFT); // ROUTE_TYPE_* set later
|
||||
|
||||
memcpy(packet->payload, ack, len);
|
||||
packet->payload_len = len;
|
||||
memcpy(packet->payload, ack_hash, ack_len);
|
||||
packet->payload_len = ack_len;
|
||||
|
||||
return packet;
|
||||
}
|
||||
|
||||
Packet* Mesh::createMultiAck(const uint8_t* ack, uint8_t len, uint8_t remaining) {
|
||||
Packet* Mesh::createAck(uint32_t ack_crc) {
|
||||
return createAck((const uint8_t*)&ack_crc, 4);
|
||||
}
|
||||
|
||||
Packet* Mesh::createMultiAck(const uint8_t* ack_hash, uint8_t ack_len, uint8_t remaining) {
|
||||
if (ack_len + 1 > sizeof(Packet::payload)) return NULL;
|
||||
|
||||
Packet* packet = obtainNewPacket();
|
||||
if (packet == NULL) {
|
||||
MESH_DEBUG_PRINTLN("%s Mesh::createMultiAck(): error, packet pool empty", getLogDateTime());
|
||||
@@ -1364,12 +1371,16 @@ Packet* Mesh::createMultiAck(const uint8_t* ack, uint8_t len, uint8_t remaining)
|
||||
packet->header = (PAYLOAD_TYPE_MULTIPART << PH_TYPE_SHIFT); // ROUTE_TYPE_* set later
|
||||
|
||||
packet->payload[0] = (remaining << 4) | PAYLOAD_TYPE_ACK;
|
||||
memcpy(&packet->payload[1], ack, len);
|
||||
packet->payload_len = 1 + len;
|
||||
memcpy(&packet->payload[1], ack_hash, ack_len);
|
||||
packet->payload_len = 1 + ack_len;
|
||||
|
||||
return packet;
|
||||
}
|
||||
|
||||
Packet* Mesh::createMultiAck(uint32_t ack_crc, uint8_t remaining) {
|
||||
return createMultiAck((const uint8_t*)&ack_crc, 4, remaining);
|
||||
}
|
||||
|
||||
Packet* Mesh::createRawData(const uint8_t* data, size_t len) {
|
||||
if (len > sizeof(Packet::payload)) return NULL; // invalid arg
|
||||
|
||||
|
||||
+17
-5
@@ -46,6 +46,8 @@ class Mesh : public Dispatcher {
|
||||
uint32_t retry_delay;
|
||||
uint8_t retry_attempts_sent;
|
||||
uint8_t retry_key[MAX_HASH_SIZE];
|
||||
uint8_t next_hop_hash[MAX_HASH_SIZE];
|
||||
uint8_t next_hop_hash_len;
|
||||
uint8_t priority;
|
||||
uint8_t progress_marker;
|
||||
bool expect_path_growth;
|
||||
@@ -132,7 +134,7 @@ protected:
|
||||
|
||||
/**
|
||||
* \brief Decide whether a DIRECT packet should get one delayed retry if the next hop echo is not overheard.
|
||||
* Sub-classes can use neighbour tables or other link-quality data to opt in selectively.
|
||||
* Sub-classes can use recent repeater or other link-quality data to opt in selectively.
|
||||
*/
|
||||
virtual bool allowDirectRetry(const Packet* packet, const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) const;
|
||||
|
||||
@@ -201,6 +203,16 @@ protected:
|
||||
*/
|
||||
virtual void onDirectRetryEvent(const char* event, const Packet* packet, uint32_t delay_millis, uint8_t retry_attempt) { }
|
||||
|
||||
/**
|
||||
* \brief Optional hook for link-quality feedback when all direct-retry attempts fail.
|
||||
*/
|
||||
virtual void onDirectRetryFailed(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) { }
|
||||
|
||||
/**
|
||||
* \brief Optional hook for link-quality feedback when a direct-retry echo is heard.
|
||||
*/
|
||||
virtual void onDirectRetrySucceeded(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len, int8_t snr_x4) { }
|
||||
|
||||
/**
|
||||
* \brief Optional hook to set local-only transmit options on a retry packet before it is queued.
|
||||
*/
|
||||
@@ -321,10 +333,10 @@ public:
|
||||
Packet* createDatagram(uint8_t type, const Identity& dest, const uint8_t* secret, const uint8_t* data, size_t len);
|
||||
Packet* createAnonDatagram(uint8_t type, const LocalIdentity& sender, const Identity& dest, const uint8_t* secret, const uint8_t* data, size_t data_len);
|
||||
Packet* createGroupDatagram(uint8_t type, const GroupChannel& channel, const uint8_t* data, size_t data_len);
|
||||
Packet* createAck(const uint8_t* ack, uint8_t len);
|
||||
Packet* createAck(uint32_t ack_crc) { return createAck((uint8_t *) &ack_crc, 4); }
|
||||
Packet* createMultiAck(const uint8_t* ack, uint8_t len, uint8_t remaining);
|
||||
Packet* createMultiAck(uint32_t ack_crc, uint8_t remaining) { return createMultiAck((uint8_t *)&ack_crc, 4, remaining); }
|
||||
Packet* createAck(const uint8_t* ack_hash, uint8_t ack_len);
|
||||
Packet* createAck(uint32_t ack_crc);
|
||||
Packet* createMultiAck(const uint8_t* ack_hash, uint8_t ack_len, uint8_t remaining);
|
||||
Packet* createMultiAck(uint32_t ack_crc, uint8_t remaining);
|
||||
Packet* createPathReturn(const uint8_t* dest_hash, const uint8_t* secret, const uint8_t* path, uint8_t path_len, uint8_t extra_type, const uint8_t*extra, size_t extra_len);
|
||||
Packet* createPathReturn(const Identity& dest, const uint8_t* secret, const uint8_t* path, uint8_t path_len, uint8_t extra_type, const uint8_t*extra, size_t extra_len);
|
||||
Packet* createRawData(const uint8_t* data, size_t len);
|
||||
|
||||
+344
-1
@@ -11,6 +11,8 @@
|
||||
#define BRIDGE_MAX_BAUD 115200
|
||||
#endif
|
||||
|
||||
#define RECENT_REPEATER_PREFIX_MAX_BYTES 3
|
||||
|
||||
// Believe it or not, this std C function is busted on some platforms!
|
||||
static uint32_t _atoi(const char* sp) {
|
||||
uint32_t n = 0;
|
||||
@@ -29,6 +31,151 @@ static bool isValidName(const char *n) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool looksNumeric(const char* s) {
|
||||
if (s == NULL) return false;
|
||||
while (*s == ' ') s++;
|
||||
if (*s == '-' || *s == '+') s++;
|
||||
bool saw_digit = false;
|
||||
bool saw_dot = false;
|
||||
while (*s) {
|
||||
if (*s >= '0' && *s <= '9') {
|
||||
saw_digit = true;
|
||||
} else if (*s == '.' && !saw_dot) {
|
||||
saw_dot = true;
|
||||
} else if (*s == ' ') {
|
||||
while (*s == ' ') s++;
|
||||
return saw_digit && *s == 0;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
s++;
|
||||
}
|
||||
return saw_digit && *s == 0;
|
||||
}
|
||||
|
||||
static bool looksUnsignedInteger(const char* s) {
|
||||
if (s == NULL) return false;
|
||||
while (*s == ' ') s++;
|
||||
bool saw_digit = false;
|
||||
while (*s) {
|
||||
if (*s >= '0' && *s <= '9') {
|
||||
saw_digit = true;
|
||||
} else if (*s == ' ') {
|
||||
while (*s == ' ') s++;
|
||||
return saw_digit && *s == 0;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
s++;
|
||||
}
|
||||
return saw_digit;
|
||||
}
|
||||
|
||||
static int16_t parseSnrDbX4(const char* s) {
|
||||
float db = atof(s);
|
||||
return (int16_t)(db * 4.0f + (db >= 0.0f ? 0.5f : -0.5f));
|
||||
}
|
||||
|
||||
static void formatSnrDbX4(char* dest, size_t dest_len, int16_t snr_x4) {
|
||||
int16_t v = snr_x4;
|
||||
const char* sign = "";
|
||||
if (v < 0) {
|
||||
sign = "-";
|
||||
v = -v;
|
||||
}
|
||||
snprintf(dest, dest_len, "%s%d.%02d", sign, v / 4, (v % 4) * 25);
|
||||
}
|
||||
|
||||
static const char* retryPresetName(uint8_t preset) {
|
||||
switch (preset) {
|
||||
case RETRY_PRESET_INFRA: return "infra";
|
||||
case RETRY_PRESET_ROOFTOP: return "rooftop";
|
||||
case RETRY_PRESET_MOBILE: return "mobile";
|
||||
default: return "custom";
|
||||
}
|
||||
}
|
||||
|
||||
static void markDirectRetryPrefsValid(NodePrefs* prefs) {
|
||||
prefs->direct_retry_prefs_magic[0] = DIRECT_RETRY_PREFS_MAGIC_0;
|
||||
prefs->direct_retry_prefs_magic[1] = DIRECT_RETRY_PREFS_MAGIC_1;
|
||||
}
|
||||
|
||||
static void applyDirectRetryPreset(NodePrefs* prefs, uint8_t preset) {
|
||||
prefs->retry_preset = preset;
|
||||
if (preset == RETRY_PRESET_INFRA) {
|
||||
prefs->direct_retry_attempts = DIRECT_RETRY_INFRA_COUNT;
|
||||
prefs->direct_retry_base_ms = DIRECT_RETRY_INFRA_BASE_MS;
|
||||
prefs->direct_retry_step_ms = DIRECT_RETRY_INFRA_STEP_MS;
|
||||
prefs->direct_retry_snr_margin_x4 = DIRECT_RETRY_INFRA_MARGIN_X4;
|
||||
} else if (preset == RETRY_PRESET_MOBILE) {
|
||||
prefs->direct_retry_attempts = DIRECT_RETRY_MOBILE_COUNT;
|
||||
prefs->direct_retry_base_ms = DIRECT_RETRY_MOBILE_BASE_MS;
|
||||
prefs->direct_retry_step_ms = DIRECT_RETRY_MOBILE_STEP_MS;
|
||||
prefs->direct_retry_snr_margin_x4 = DIRECT_RETRY_MOBILE_MARGIN_X4;
|
||||
} else {
|
||||
prefs->retry_preset = RETRY_PRESET_ROOFTOP;
|
||||
prefs->direct_retry_attempts = DIRECT_RETRY_ROOFTOP_COUNT;
|
||||
prefs->direct_retry_base_ms = DIRECT_RETRY_ROOFTOP_BASE_MS;
|
||||
prefs->direct_retry_step_ms = DIRECT_RETRY_ROOFTOP_STEP_MS;
|
||||
prefs->direct_retry_snr_margin_x4 = DIRECT_RETRY_ROOFTOP_MARGIN_X4;
|
||||
}
|
||||
markDirectRetryPrefsValid(prefs);
|
||||
}
|
||||
|
||||
static void setDefaultDirectRetryPrefs(NodePrefs* prefs) {
|
||||
applyDirectRetryPreset(prefs, RETRY_PRESET_ROOFTOP);
|
||||
prefs->direct_retry_cr_enabled = 1;
|
||||
prefs->direct_retry_cr4_snr_x4 = DIRECT_RETRY_CR4_MIN_SNR_X4_DEFAULT;
|
||||
prefs->direct_retry_cr5_snr_x4 = DIRECT_RETRY_CR5_MIN_SNR_X4_DEFAULT;
|
||||
prefs->direct_retry_cr7_snr_x4 = DIRECT_RETRY_CR7_MIN_SNR_X4_DEFAULT;
|
||||
prefs->direct_retry_cr8_snr_x4 = DIRECT_RETRY_CR8_MAX_SNR_X4_DEFAULT;
|
||||
prefs->direct_retry_enabled = 1;
|
||||
markDirectRetryPrefsValid(prefs);
|
||||
}
|
||||
|
||||
static bool directRetryPrefsValid(const NodePrefs* prefs) {
|
||||
return prefs->direct_retry_prefs_magic[0] == DIRECT_RETRY_PREFS_MAGIC_0
|
||||
&& prefs->direct_retry_prefs_magic[1] == DIRECT_RETRY_PREFS_MAGIC_1;
|
||||
}
|
||||
|
||||
static bool parseRetryPreset(const char* s, uint8_t& preset) {
|
||||
if (strcmp(s, "infra") == 0 || strcmp(s, "0") == 0) {
|
||||
preset = RETRY_PRESET_INFRA;
|
||||
return true;
|
||||
}
|
||||
if (strcmp(s, "rooftop") == 0 || strcmp(s, "1") == 0) {
|
||||
preset = RETRY_PRESET_ROOFTOP;
|
||||
return true;
|
||||
}
|
||||
if (strcmp(s, "mobile") == 0 || strcmp(s, "2") == 0) {
|
||||
preset = RETRY_PRESET_MOBILE;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool parseHashPrefix(const char* text, uint8_t* prefix, uint8_t& prefix_len) {
|
||||
size_t hex_len = strlen(text);
|
||||
if (hex_len == 0 || (hex_len & 1) || hex_len > RECENT_REPEATER_PREFIX_MAX_BYTES * 2) {
|
||||
return false;
|
||||
}
|
||||
for (size_t i = 0; i < hex_len; i++) {
|
||||
if (!mesh::Utils::isHexChar(text[i])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
prefix_len = hex_len / 2;
|
||||
return mesh::Utils::fromHex(prefix, prefix_len, text);
|
||||
}
|
||||
|
||||
static void formatSnrDbX4Short(char* dest, size_t dest_len, int16_t snr_x4) {
|
||||
formatSnrDbX4(dest, dest_len, snr_x4);
|
||||
size_t len = strlen(dest);
|
||||
if (len > 3 && dest[len - 1] == '0') {
|
||||
dest[len - 1] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void CommonCLI::loadPrefs(FILESYSTEM* fs) {
|
||||
if (fs->exists("/com_prefs")) {
|
||||
loadPrefsInt(fs, "/com_prefs"); // new filename
|
||||
@@ -97,6 +244,19 @@ void CommonCLI::loadPrefsInt(FILESYSTEM* fs, const char* filename) {
|
||||
file.read((uint8_t *)&_prefs->radio_fem_rxgain, sizeof(_prefs->radio_fem_rxgain)); // 293
|
||||
file.read((uint8_t *)&_prefs->cad_enabled, sizeof(_prefs->cad_enabled)); // 294
|
||||
// next: 295
|
||||
file.read((uint8_t *)&_prefs->retry_preset, sizeof(_prefs->retry_preset)); // 295
|
||||
file.read((uint8_t *)&_prefs->direct_retry_attempts, sizeof(_prefs->direct_retry_attempts)); // 296
|
||||
file.read((uint8_t *)&_prefs->direct_retry_base_ms, sizeof(_prefs->direct_retry_base_ms)); // 297
|
||||
file.read((uint8_t *)&_prefs->direct_retry_step_ms, sizeof(_prefs->direct_retry_step_ms)); // 299
|
||||
file.read((uint8_t *)&_prefs->direct_retry_snr_margin_x4, sizeof(_prefs->direct_retry_snr_margin_x4)); // 301
|
||||
file.read((uint8_t *)&_prefs->direct_retry_cr4_snr_x4, sizeof(_prefs->direct_retry_cr4_snr_x4)); // 303
|
||||
file.read((uint8_t *)&_prefs->direct_retry_cr5_snr_x4, sizeof(_prefs->direct_retry_cr5_snr_x4)); // 304
|
||||
file.read((uint8_t *)&_prefs->direct_retry_cr7_snr_x4, sizeof(_prefs->direct_retry_cr7_snr_x4)); // 305
|
||||
file.read((uint8_t *)&_prefs->direct_retry_cr8_snr_x4, sizeof(_prefs->direct_retry_cr8_snr_x4)); // 306
|
||||
file.read((uint8_t *)&_prefs->direct_retry_enabled, sizeof(_prefs->direct_retry_enabled)); // 307
|
||||
file.read((uint8_t *)&_prefs->direct_retry_cr_enabled, sizeof(_prefs->direct_retry_cr_enabled)); // 308
|
||||
file.read((uint8_t *)&_prefs->direct_retry_prefs_magic, sizeof(_prefs->direct_retry_prefs_magic)); // 309
|
||||
// next: 311
|
||||
|
||||
// sanitise bad pref values
|
||||
_prefs->rx_delay_base = constrain(_prefs->rx_delay_base, 0, 20.0f);
|
||||
@@ -129,6 +289,18 @@ void CommonCLI::loadPrefsInt(FILESYSTEM* fs, const char* filename) {
|
||||
_prefs->rx_boosted_gain = constrain(_prefs->rx_boosted_gain, 0, 1); // boolean
|
||||
_prefs->radio_fem_rxgain = constrain(_prefs->radio_fem_rxgain, 0, 1); // boolean
|
||||
_prefs->cad_enabled = constrain(_prefs->cad_enabled, 0, 1); // boolean
|
||||
if (!directRetryPrefsValid(_prefs)) {
|
||||
setDefaultDirectRetryPrefs(_prefs);
|
||||
}
|
||||
if (_prefs->retry_preset > RETRY_PRESET_MOBILE && _prefs->retry_preset != RETRY_PRESET_CUSTOM) {
|
||||
_prefs->retry_preset = RETRY_PRESET_CUSTOM;
|
||||
}
|
||||
_prefs->direct_retry_attempts = constrain(_prefs->direct_retry_attempts, 1, 15);
|
||||
_prefs->direct_retry_base_ms = constrain(_prefs->direct_retry_base_ms, 10, 5000);
|
||||
_prefs->direct_retry_step_ms = constrain(_prefs->direct_retry_step_ms, 0, 5000);
|
||||
_prefs->direct_retry_snr_margin_x4 = constrain(_prefs->direct_retry_snr_margin_x4, 0, 160);
|
||||
_prefs->direct_retry_enabled = constrain(_prefs->direct_retry_enabled, 0, 1);
|
||||
_prefs->direct_retry_cr_enabled = constrain(_prefs->direct_retry_cr_enabled, 0, 1);
|
||||
|
||||
file.close();
|
||||
}
|
||||
@@ -196,6 +368,20 @@ void CommonCLI::savePrefs(FILESYSTEM* fs) {
|
||||
file.write((uint8_t *)&_prefs->radio_fem_rxgain, sizeof(_prefs->radio_fem_rxgain)); // 293
|
||||
file.write((uint8_t *)&_prefs->cad_enabled, sizeof(_prefs->cad_enabled)); // 294
|
||||
// next: 295
|
||||
markDirectRetryPrefsValid(_prefs);
|
||||
file.write((uint8_t *)&_prefs->retry_preset, sizeof(_prefs->retry_preset)); // 295
|
||||
file.write((uint8_t *)&_prefs->direct_retry_attempts, sizeof(_prefs->direct_retry_attempts)); // 296
|
||||
file.write((uint8_t *)&_prefs->direct_retry_base_ms, sizeof(_prefs->direct_retry_base_ms)); // 297
|
||||
file.write((uint8_t *)&_prefs->direct_retry_step_ms, sizeof(_prefs->direct_retry_step_ms)); // 299
|
||||
file.write((uint8_t *)&_prefs->direct_retry_snr_margin_x4, sizeof(_prefs->direct_retry_snr_margin_x4)); // 301
|
||||
file.write((uint8_t *)&_prefs->direct_retry_cr4_snr_x4, sizeof(_prefs->direct_retry_cr4_snr_x4)); // 303
|
||||
file.write((uint8_t *)&_prefs->direct_retry_cr5_snr_x4, sizeof(_prefs->direct_retry_cr5_snr_x4)); // 304
|
||||
file.write((uint8_t *)&_prefs->direct_retry_cr7_snr_x4, sizeof(_prefs->direct_retry_cr7_snr_x4)); // 305
|
||||
file.write((uint8_t *)&_prefs->direct_retry_cr8_snr_x4, sizeof(_prefs->direct_retry_cr8_snr_x4)); // 306
|
||||
file.write((uint8_t *)&_prefs->direct_retry_enabled, sizeof(_prefs->direct_retry_enabled)); // 307
|
||||
file.write((uint8_t *)&_prefs->direct_retry_cr_enabled, sizeof(_prefs->direct_retry_cr_enabled)); // 308
|
||||
file.write((uint8_t *)&_prefs->direct_retry_prefs_magic, sizeof(_prefs->direct_retry_prefs_magic)); // 309
|
||||
// next: 311
|
||||
|
||||
file.close();
|
||||
}
|
||||
@@ -306,6 +492,9 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* re
|
||||
} else if (memcmp(command, "clear stats", 11) == 0) {
|
||||
_callbacks->clearStats();
|
||||
strcpy(reply, "(OK - stats reset)");
|
||||
} else if (memcmp(command, "clear recent.repeater", 21) == 0 && (command[21] == 0 || command[21] == ' ')) {
|
||||
_callbacks->clearRecentRepeaters();
|
||||
strcpy(reply, "OK");
|
||||
} else if (memcmp(command, "get ", 4) == 0) {
|
||||
handleGetCmd(sender_timestamp, command, reply);
|
||||
} else if (memcmp(command, "set ", 4) == 0) {
|
||||
@@ -481,7 +670,7 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* re
|
||||
// GPS
|
||||
#if defined(PIN_GPS_RX) && defined(PIN_GPS_TX)
|
||||
sprintf(reply + strlen(reply), "GPS Serial: RX=%s, TX=%s", STR(PIN_GPS_RX), STR(PIN_GPS_TX));
|
||||
#ifdef ENV_INCLUDE_GPS> 0
|
||||
#if defined(ENV_INCLUDE_GPS) && ENV_INCLUDE_GPS > 0
|
||||
sprintf(reply + strlen(reply), ". Configured");
|
||||
#else
|
||||
sprintf(reply + strlen(reply), ". Not configured");
|
||||
@@ -715,6 +904,128 @@ void CommonCLI::handleSetCmd(uint32_t sender_timestamp, char* command, char* rep
|
||||
} else {
|
||||
strcpy(reply, "Error, must be 0-2");
|
||||
}
|
||||
} else if (memcmp(config, "retry.preset ", 13) == 0) {
|
||||
uint8_t preset;
|
||||
if (parseRetryPreset(&config[13], preset)) {
|
||||
applyDirectRetryPreset(_prefs, preset);
|
||||
savePrefs();
|
||||
sprintf(reply, "OK - %s", retryPresetName(_prefs->retry_preset));
|
||||
} else {
|
||||
strcpy(reply, "Error, must be infra, rooftop, or mobile");
|
||||
}
|
||||
} else if (memcmp(config, "direct.retry ", 13) == 0) {
|
||||
if (strcmp(&config[13], "on") == 0) {
|
||||
_prefs->direct_retry_enabled = 1;
|
||||
savePrefs();
|
||||
strcpy(reply, "OK");
|
||||
} else if (strcmp(&config[13], "off") == 0) {
|
||||
_prefs->direct_retry_enabled = 0;
|
||||
savePrefs();
|
||||
strcpy(reply, "OK");
|
||||
} else {
|
||||
strcpy(reply, "Error, must be on or off");
|
||||
}
|
||||
} else if (memcmp(config, "direct.retry.margin ", 20) == 0) {
|
||||
if (!looksNumeric(&config[20])) {
|
||||
strcpy(reply, "Error, must be 0-40 dB");
|
||||
} else {
|
||||
int16_t margin_x4 = parseSnrDbX4(&config[20]);
|
||||
if (margin_x4 >= 0 && margin_x4 <= 160) {
|
||||
_prefs->direct_retry_snr_margin_x4 = (uint16_t)margin_x4;
|
||||
_prefs->retry_preset = RETRY_PRESET_CUSTOM;
|
||||
savePrefs();
|
||||
strcpy(reply, "OK");
|
||||
} else {
|
||||
strcpy(reply, "Error, must be 0-40 dB");
|
||||
}
|
||||
}
|
||||
} else if (memcmp(config, "direct.retry.count ", 19) == 0) {
|
||||
int attempts = looksUnsignedInteger(&config[19]) ? _atoi(&config[19]) : -1;
|
||||
if (attempts >= 1 && attempts <= 15) {
|
||||
_prefs->direct_retry_attempts = (uint8_t)attempts;
|
||||
_prefs->retry_preset = RETRY_PRESET_CUSTOM;
|
||||
savePrefs();
|
||||
strcpy(reply, "OK");
|
||||
} else {
|
||||
strcpy(reply, "Error, must be 1-15");
|
||||
}
|
||||
} else if (memcmp(config, "direct.retry.base ", 18) == 0) {
|
||||
int base_ms = looksUnsignedInteger(&config[18]) ? _atoi(&config[18]) : -1;
|
||||
if (base_ms >= 10 && base_ms <= 5000) {
|
||||
_prefs->direct_retry_base_ms = (uint16_t)base_ms;
|
||||
_prefs->retry_preset = RETRY_PRESET_CUSTOM;
|
||||
savePrefs();
|
||||
strcpy(reply, "OK");
|
||||
} else {
|
||||
strcpy(reply, "Error, must be 10-5000 ms");
|
||||
}
|
||||
} else if (memcmp(config, "direct.retry.step ", 18) == 0) {
|
||||
int step_ms = looksUnsignedInteger(&config[18]) ? _atoi(&config[18]) : -1;
|
||||
if (step_ms >= 0 && step_ms <= 5000) {
|
||||
_prefs->direct_retry_step_ms = (uint16_t)step_ms;
|
||||
_prefs->retry_preset = RETRY_PRESET_CUSTOM;
|
||||
savePrefs();
|
||||
strcpy(reply, "OK");
|
||||
} else {
|
||||
strcpy(reply, "Error, must be 0-5000 ms");
|
||||
}
|
||||
} else if (memcmp(config, "direct.retry.cr ", 16) == 0) {
|
||||
if (strcmp(&config[16], "off") == 0) {
|
||||
_prefs->direct_retry_cr_enabled = 0;
|
||||
savePrefs();
|
||||
strcpy(reply, "OK");
|
||||
} else {
|
||||
strcpy(tmp, &config[16]);
|
||||
const char *parts[4];
|
||||
int num = mesh::Utils::parseTextParts(tmp, parts, 4, ',');
|
||||
if (num == 4 && looksNumeric(parts[0]) && looksNumeric(parts[1]) && looksNumeric(parts[2]) && looksNumeric(parts[3])) {
|
||||
int16_t cr4 = parseSnrDbX4(parts[0]);
|
||||
int16_t cr5 = parseSnrDbX4(parts[1]);
|
||||
int16_t cr7 = parseSnrDbX4(parts[2]);
|
||||
int16_t cr8 = parseSnrDbX4(parts[3]);
|
||||
if (cr4 >= -128 && cr4 <= 127 && cr5 >= -128 && cr5 <= 127 && cr7 >= -128 && cr7 <= 127 && cr8 >= -128 && cr8 <= 127) {
|
||||
_prefs->direct_retry_cr4_snr_x4 = (int8_t)cr4;
|
||||
_prefs->direct_retry_cr5_snr_x4 = (int8_t)cr5;
|
||||
_prefs->direct_retry_cr7_snr_x4 = (int8_t)cr7;
|
||||
_prefs->direct_retry_cr8_snr_x4 = (int8_t)cr8;
|
||||
_prefs->direct_retry_cr_enabled = 1;
|
||||
savePrefs();
|
||||
strcpy(reply, "OK");
|
||||
} else {
|
||||
strcpy(reply, "Error, SNR must fit -32.00..31.75 dB");
|
||||
}
|
||||
} else {
|
||||
strcpy(reply, "Error, use CR4,CR5,CR7,CR8 SNRs or off");
|
||||
}
|
||||
}
|
||||
} else if (memcmp(config, "recent.repeater ", 16) == 0) {
|
||||
strcpy(tmp, &config[16]);
|
||||
const char *parts[2];
|
||||
int num = mesh::Utils::parseTextParts(tmp, parts, 2, ' ');
|
||||
uint8_t prefix[MAX_HASH_SIZE];
|
||||
uint8_t prefix_len = 0;
|
||||
int16_t snr_x4 = 12; // default to +3.0 dB when omitted or invalid
|
||||
if (num < 1 || !parseHashPrefix(parts[0], prefix, prefix_len)) {
|
||||
strcpy(reply, "Error, use: set recent.repeater <hex> [snr_db]");
|
||||
} else if (num > 1 && !looksNumeric(parts[1])) {
|
||||
strcpy(reply, "Error, SNR must be numeric");
|
||||
} else {
|
||||
if (num > 1) {
|
||||
snr_x4 = parseSnrDbX4(parts[1]);
|
||||
}
|
||||
if (snr_x4 < -128 || snr_x4 > 127) {
|
||||
strcpy(reply, "Error, SNR must fit -32.00..31.75 dB");
|
||||
} else if (_callbacks->setRecentRepeater(prefix, prefix_len, (int8_t)snr_x4)) {
|
||||
char prefix_hex[RECENT_REPEATER_PREFIX_MAX_BYTES * 2 + 1];
|
||||
char snr[12];
|
||||
mesh::Utils::toHex(prefix_hex, prefix, prefix_len);
|
||||
prefix_hex[prefix_len * 2] = 0;
|
||||
formatSnrDbX4Short(snr, sizeof(snr), snr_x4);
|
||||
sprintf(reply, "OK - set %s at %s SNR", prefix_hex, snr);
|
||||
} else {
|
||||
strcpy(reply, "Error, table rejected prefix");
|
||||
}
|
||||
}
|
||||
} else if (memcmp(config, "owner.info ", 11) == 0) {
|
||||
config += 11;
|
||||
char *dp = _prefs->owner_info;
|
||||
@@ -910,6 +1221,38 @@ void CommonCLI::handleGetCmd(uint32_t sender_timestamp, char* command, char* rep
|
||||
sprintf(reply, "> %d", (uint32_t)_prefs->flood_max);
|
||||
} else if (memcmp(config, "direct.txdelay", 14) == 0) {
|
||||
sprintf(reply, "> %s", StrHelper::ftoa(_prefs->direct_tx_delay_factor));
|
||||
} else if (memcmp(config, "retry.preset", 12) == 0) {
|
||||
sprintf(reply, "> %s", retryPresetName(_prefs->retry_preset));
|
||||
} else if (memcmp(config, "direct.retry", 12) == 0 && (config[12] == 0 || config[12] == ' ')) {
|
||||
sprintf(reply, "> %s", _prefs->direct_retry_enabled ? "on" : "off");
|
||||
} else if (memcmp(config, "direct.retry.margin", 19) == 0) {
|
||||
char margin[12];
|
||||
formatSnrDbX4(margin, sizeof(margin), _prefs->direct_retry_snr_margin_x4);
|
||||
sprintf(reply, "> %s", margin);
|
||||
} else if (memcmp(config, "direct.retry.count", 18) == 0) {
|
||||
sprintf(reply, "> %d", (uint32_t)_prefs->direct_retry_attempts);
|
||||
} else if (memcmp(config, "direct.retry.base", 17) == 0) {
|
||||
sprintf(reply, "> %d", (uint32_t)_prefs->direct_retry_base_ms);
|
||||
} else if (memcmp(config, "direct.retry.step", 17) == 0) {
|
||||
sprintf(reply, "> %d", (uint32_t)_prefs->direct_retry_step_ms);
|
||||
} else if (memcmp(config, "direct.retry.cr", 15) == 0) {
|
||||
if (!_prefs->direct_retry_cr_enabled) {
|
||||
strcpy(reply, "> off");
|
||||
} else {
|
||||
char cr4[12], cr5[12], cr7[12], cr8[12];
|
||||
formatSnrDbX4(cr4, sizeof(cr4), _prefs->direct_retry_cr4_snr_x4);
|
||||
formatSnrDbX4(cr5, sizeof(cr5), _prefs->direct_retry_cr5_snr_x4);
|
||||
formatSnrDbX4(cr7, sizeof(cr7), _prefs->direct_retry_cr7_snr_x4);
|
||||
formatSnrDbX4(cr8, sizeof(cr8), _prefs->direct_retry_cr8_snr_x4);
|
||||
sprintf(reply, "> %s,%s,%s,%s", cr4, cr5, cr7, cr8);
|
||||
}
|
||||
} else if (memcmp(config, "recent.repeater", 15) == 0) {
|
||||
int page = 1;
|
||||
const char* cursor = &config[15];
|
||||
while (*cursor == ' ') cursor++;
|
||||
if (*cursor) page = _atoi(cursor);
|
||||
if (page < 1) page = 1;
|
||||
_callbacks->formatRecentRepeatersReply(reply, page);
|
||||
} else if (memcmp(config, "owner.info", 10) == 0) {
|
||||
auto start = reply;
|
||||
*reply++ = '>';
|
||||
|
||||
@@ -19,6 +19,34 @@
|
||||
#define LOOP_DETECT_MODERATE 2
|
||||
#define LOOP_DETECT_STRICT 3
|
||||
|
||||
#define RETRY_PRESET_INFRA 0
|
||||
#define RETRY_PRESET_ROOFTOP 1
|
||||
#define RETRY_PRESET_MOBILE 2
|
||||
#define RETRY_PRESET_CUSTOM 0xFF
|
||||
|
||||
#define DIRECT_RETRY_INFRA_BASE_MS 275
|
||||
#define DIRECT_RETRY_INFRA_COUNT 4
|
||||
#define DIRECT_RETRY_INFRA_STEP_MS 150
|
||||
#define DIRECT_RETRY_INFRA_MARGIN_X4 60
|
||||
|
||||
#define DIRECT_RETRY_ROOFTOP_BASE_MS 175
|
||||
#define DIRECT_RETRY_ROOFTOP_COUNT 15
|
||||
#define DIRECT_RETRY_ROOFTOP_STEP_MS 100
|
||||
#define DIRECT_RETRY_ROOFTOP_MARGIN_X4 20
|
||||
|
||||
#define DIRECT_RETRY_MOBILE_BASE_MS 175
|
||||
#define DIRECT_RETRY_MOBILE_COUNT 15
|
||||
#define DIRECT_RETRY_MOBILE_STEP_MS 50
|
||||
#define DIRECT_RETRY_MOBILE_MARGIN_X4 0
|
||||
|
||||
#define DIRECT_RETRY_CR4_MIN_SNR_X4_DEFAULT 40
|
||||
#define DIRECT_RETRY_CR5_MIN_SNR_X4_DEFAULT 30
|
||||
#define DIRECT_RETRY_CR7_MIN_SNR_X4_DEFAULT 10
|
||||
#define DIRECT_RETRY_CR8_MAX_SNR_X4_DEFAULT 10
|
||||
|
||||
#define DIRECT_RETRY_PREFS_MAGIC_0 0xD1
|
||||
#define DIRECT_RETRY_PREFS_MAGIC_1 0x52
|
||||
|
||||
struct NodePrefs { // persisted to file
|
||||
float airtime_factor;
|
||||
char node_name[32];
|
||||
@@ -66,6 +94,18 @@ struct NodePrefs { // persisted to file
|
||||
uint8_t path_hash_mode; // which path mode to use when sending
|
||||
uint8_t loop_detect;
|
||||
uint8_t cad_enabled; // hardware Channel Activity Detection before TX (boolean)
|
||||
uint8_t retry_preset;
|
||||
uint8_t direct_retry_attempts;
|
||||
uint16_t direct_retry_base_ms;
|
||||
uint16_t direct_retry_step_ms;
|
||||
uint16_t direct_retry_snr_margin_x4;
|
||||
int8_t direct_retry_cr4_snr_x4;
|
||||
int8_t direct_retry_cr5_snr_x4;
|
||||
int8_t direct_retry_cr7_snr_x4;
|
||||
int8_t direct_retry_cr8_snr_x4;
|
||||
uint8_t direct_retry_enabled;
|
||||
uint8_t direct_retry_cr_enabled;
|
||||
uint8_t direct_retry_prefs_magic[2];
|
||||
};
|
||||
|
||||
class CommonCLICallbacks {
|
||||
@@ -89,6 +129,18 @@ public:
|
||||
virtual void formatStatsReply(char *reply) = 0;
|
||||
virtual void formatRadioStatsReply(char *reply) = 0;
|
||||
virtual void formatPacketStatsReply(char *reply) = 0;
|
||||
virtual void formatRecentRepeatersReply(char *reply, int page) {
|
||||
(void)page;
|
||||
if (reply != NULL) reply[0] = 0;
|
||||
}
|
||||
virtual bool setRecentRepeater(const uint8_t* prefix, uint8_t prefix_len, int8_t snr_x4) {
|
||||
(void)prefix;
|
||||
(void)prefix_len;
|
||||
(void)snr_x4;
|
||||
return false;
|
||||
}
|
||||
virtual void clearRecentRepeaters() {
|
||||
}
|
||||
virtual mesh::LocalIdentity& getSelfId() = 0;
|
||||
virtual void saveIdentity(const mesh::LocalIdentity& new_id) = 0;
|
||||
virtual void clearStats() = 0;
|
||||
|
||||
+275
-11
@@ -7,23 +7,143 @@
|
||||
#endif
|
||||
|
||||
#define MAX_PACKET_HASHES (128+32)
|
||||
#ifndef MAX_RECENT_REPEATERS
|
||||
// Platform defaults. Can be overridden with -D MAX_RECENT_REPEATERS=<n>.
|
||||
#if defined(ESP32) || defined(ESP32_PLATFORM)
|
||||
#define MAX_RECENT_REPEATERS 2048
|
||||
#elif defined(NRF52_PLATFORM)
|
||||
#define MAX_RECENT_REPEATERS 512
|
||||
#else
|
||||
#define MAX_RECENT_REPEATERS 64
|
||||
#endif
|
||||
#endif
|
||||
#define MAX_ROUTE_HASH_BYTES 3
|
||||
|
||||
class SimpleMeshTables : public mesh::MeshTables {
|
||||
public:
|
||||
struct RecentRepeaterInfo {
|
||||
// Identity and link quality for a next-hop path prefix.
|
||||
uint8_t prefix[MAX_ROUTE_HASH_BYTES];
|
||||
uint8_t prefix_len;
|
||||
int8_t snr_x4;
|
||||
};
|
||||
|
||||
private:
|
||||
uint8_t _hashes[MAX_PACKET_HASHES*MAX_HASH_SIZE];
|
||||
int _next_idx;
|
||||
uint32_t _direct_dups, _flood_dups;
|
||||
RecentRepeaterInfo _recent_repeaters[MAX_RECENT_REPEATERS];
|
||||
|
||||
bool hasSeenHash(const uint8_t* hash) const {
|
||||
const uint8_t* sp = _hashes;
|
||||
for (int i = 0; i < MAX_PACKET_HASHES; i++, sp += MAX_HASH_SIZE) {
|
||||
if (memcmp(hash, sp, MAX_HASH_SIZE) == 0) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void storeHash(const uint8_t* hash) {
|
||||
memcpy(&_hashes[_next_idx*MAX_HASH_SIZE], hash, MAX_HASH_SIZE);
|
||||
_next_idx = (_next_idx + 1) % MAX_PACKET_HASHES;
|
||||
}
|
||||
|
||||
bool prefixesOverlap(const uint8_t* a, uint8_t a_len, const uint8_t* b, uint8_t b_len) const {
|
||||
uint8_t n = a_len < b_len ? a_len : b_len;
|
||||
return n > 0 && memcmp(a, b, n) == 0;
|
||||
}
|
||||
|
||||
int8_t weightedSnrX4RoundUp(int8_t curr_snr_x4, int8_t new_snr_x4) const {
|
||||
// Keep existing SNR heavier than a single new sample: 75% existing + 25% new.
|
||||
int32_t weighted_sum = ((int32_t)curr_snr_x4 * 3) + (int32_t)new_snr_x4;
|
||||
int32_t blended = weighted_sum / 4; // truncates toward zero
|
||||
// "Round up" means ceil(), which only differs from truncation for positive remainders.
|
||||
if (weighted_sum > 0 && (weighted_sum % 4) != 0) {
|
||||
blended++;
|
||||
}
|
||||
if (blended > 127) {
|
||||
blended = 127;
|
||||
} else if (blended < -128) {
|
||||
blended = -128;
|
||||
}
|
||||
return (int8_t)blended;
|
||||
}
|
||||
|
||||
bool extractRecentRepeater(const mesh::Packet* packet, uint8_t* prefix, uint8_t& prefix_len) const {
|
||||
// Learn repeater prefixes only from packet shapes that expose a trustworthy repeater ID.
|
||||
// For flood traffic, the last path entry is the repeater we directly heard.
|
||||
if (packet->isRouteFlood() && packet->getPathHashCount() > 0) {
|
||||
prefix_len = packet->getPathHashSize();
|
||||
if (prefix_len > MAX_ROUTE_HASH_BYTES) {
|
||||
prefix_len = MAX_ROUTE_HASH_BYTES;
|
||||
}
|
||||
|
||||
const uint8_t* last_hop = &packet->path[(packet->getPathHashCount() - 1) * packet->getPathHashSize()];
|
||||
memcpy(prefix, last_hop, prefix_len);
|
||||
return true;
|
||||
}
|
||||
|
||||
// If there is no flood path to inspect, fall back to payload-derived identities.
|
||||
if (packet->getPayloadType() == PAYLOAD_TYPE_ADVERT && packet->payload_len >= PUB_KEY_SIZE) {
|
||||
memcpy(prefix, packet->payload, MAX_ROUTE_HASH_BYTES);
|
||||
prefix_len = MAX_ROUTE_HASH_BYTES;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (packet->getPayloadType() == PAYLOAD_TYPE_CONTROL
|
||||
&& packet->isRouteDirect()
|
||||
&& packet->getPathHashCount() == 0
|
||||
&& packet->payload_len >= 6 + MAX_ROUTE_HASH_BYTES
|
||||
&& (packet->payload[0] & 0xF0) == 0x90) {
|
||||
memcpy(prefix, &packet->payload[6], MAX_ROUTE_HASH_BYTES);
|
||||
prefix_len = MAX_ROUTE_HASH_BYTES;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool recentRepeaterComesBefore(const RecentRepeaterInfo& a, int a_idx,
|
||||
const RecentRepeaterInfo& b, int b_idx) const {
|
||||
if (a.prefix_len != b.prefix_len) {
|
||||
return a.prefix_len > b.prefix_len; // 3-byte prefixes, then 2-byte, then 1-byte.
|
||||
}
|
||||
if (a.snr_x4 != b.snr_x4) {
|
||||
return a.snr_x4 > b.snr_x4; // Highest SNR first within each prefix length.
|
||||
}
|
||||
int cmp = memcmp(a.prefix, b.prefix, a.prefix_len);
|
||||
if (cmp != 0) {
|
||||
return cmp < 0;
|
||||
}
|
||||
return a_idx < b_idx;
|
||||
}
|
||||
|
||||
void recordRecentRepeater(const mesh::Packet* packet) {
|
||||
uint8_t prefix[MAX_ROUTE_HASH_BYTES] = {0};
|
||||
uint8_t prefix_len = 0;
|
||||
if (!extractRecentRepeater(packet, prefix, prefix_len) || prefix_len == 0) {
|
||||
return;
|
||||
}
|
||||
setRecentRepeater(prefix, prefix_len, packet->_snr);
|
||||
}
|
||||
|
||||
public:
|
||||
SimpleMeshTables() {
|
||||
memset(_hashes, 0, sizeof(_hashes));
|
||||
_next_idx = 0;
|
||||
_direct_dups = _flood_dups = 0;
|
||||
memset(_recent_repeaters, 0, sizeof(_recent_repeaters));
|
||||
}
|
||||
|
||||
#ifdef ESP32
|
||||
void restoreFrom(File f) {
|
||||
f.read(_hashes, sizeof(_hashes));
|
||||
f.read((uint8_t *) &_next_idx, sizeof(_next_idx));
|
||||
// Recent repeater entries are intentionally not restored across boots.
|
||||
// This avoids struct-layout migration issues and keeps stale path quality
|
||||
// stats from persisting indefinitely.
|
||||
memset(_recent_repeaters, 0, sizeof(_recent_repeaters));
|
||||
}
|
||||
void saveTo(File f) {
|
||||
f.write(_hashes, sizeof(_hashes));
|
||||
@@ -35,23 +155,29 @@ public:
|
||||
uint8_t hash[MAX_HASH_SIZE];
|
||||
packet->calculatePacketHash(hash);
|
||||
|
||||
const uint8_t* sp = _hashes;
|
||||
for (int i = 0; i < MAX_PACKET_HASHES; i++, sp += MAX_HASH_SIZE) {
|
||||
if (memcmp(hash, sp, MAX_HASH_SIZE) == 0) {
|
||||
if (packet->isRouteDirect()) {
|
||||
_direct_dups++; // keep some stats
|
||||
} else {
|
||||
_flood_dups++;
|
||||
}
|
||||
return true;
|
||||
if (hasSeenHash(hash)) {
|
||||
if (packet->isRouteDirect()) {
|
||||
_direct_dups++; // keep some stats
|
||||
} else {
|
||||
_flood_dups++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
memcpy(&_hashes[_next_idx*MAX_HASH_SIZE], hash, MAX_HASH_SIZE);
|
||||
_next_idx = (_next_idx + 1) % MAX_PACKET_HASHES; // cyclic table
|
||||
storeHash(hash);
|
||||
recordRecentRepeater(packet);
|
||||
return false;
|
||||
}
|
||||
|
||||
void markSent(const mesh::Packet* packet) override {
|
||||
// Outbound packets must be marked as already-sent without teaching the recent-heard cache about ourselves.
|
||||
uint8_t hash[MAX_HASH_SIZE];
|
||||
packet->calculatePacketHash(hash);
|
||||
if (!hasSeenHash(hash)) {
|
||||
storeHash(hash);
|
||||
}
|
||||
}
|
||||
|
||||
void clear(const mesh::Packet* packet) override {
|
||||
uint8_t hash[MAX_HASH_SIZE];
|
||||
packet->calculatePacketHash(hash);
|
||||
@@ -68,5 +194,143 @@ public:
|
||||
uint32_t getNumDirectDups() const { return _direct_dups; }
|
||||
uint32_t getNumFloodDups() const { return _flood_dups; }
|
||||
|
||||
bool setRecentRepeater(const uint8_t* prefix, uint8_t prefix_len, int8_t snr_x4) {
|
||||
if (prefix == NULL || prefix_len == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (prefix_len > MAX_ROUTE_HASH_BYTES) {
|
||||
prefix_len = MAX_ROUTE_HASH_BYTES;
|
||||
}
|
||||
|
||||
// Keep exact prefixes distinct so a 1-byte path prefix does not collapse
|
||||
// independent 2/3-byte repeaters that share the same first byte.
|
||||
for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
|
||||
RecentRepeaterInfo& existing = _recent_repeaters[i];
|
||||
if (existing.prefix_len != prefix_len || memcmp(existing.prefix, prefix, prefix_len) != 0) {
|
||||
continue;
|
||||
}
|
||||
existing.snr_x4 = weightedSnrX4RoundUp(existing.snr_x4, snr_x4);
|
||||
return true;
|
||||
}
|
||||
|
||||
int slot_idx = -1;
|
||||
for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
|
||||
if (_recent_repeaters[i].prefix_len == 0) {
|
||||
slot_idx = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (slot_idx < 0) {
|
||||
// Table is full: evict the weakest observed SNR entry.
|
||||
slot_idx = 0;
|
||||
int8_t min_snr_x4 = _recent_repeaters[0].snr_x4;
|
||||
for (int i = 1; i < MAX_RECENT_REPEATERS; i++) {
|
||||
if (_recent_repeaters[i].snr_x4 < min_snr_x4) {
|
||||
min_snr_x4 = _recent_repeaters[i].snr_x4;
|
||||
slot_idx = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
RecentRepeaterInfo& slot = _recent_repeaters[slot_idx];
|
||||
memset(slot.prefix, 0, sizeof(slot.prefix));
|
||||
memcpy(slot.prefix, prefix, prefix_len);
|
||||
slot.prefix_len = prefix_len;
|
||||
slot.snr_x4 = snr_x4;
|
||||
return true;
|
||||
}
|
||||
bool decrementRecentRepeaterSnrX4(const uint8_t* prefix, uint8_t prefix_len, uint8_t amount_x4 = 1) {
|
||||
if (prefix == NULL || prefix_len == 0 || amount_x4 == 0) {
|
||||
return false;
|
||||
}
|
||||
if (prefix_len > MAX_ROUTE_HASH_BYTES) {
|
||||
prefix_len = MAX_ROUTE_HASH_BYTES;
|
||||
}
|
||||
|
||||
for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
|
||||
RecentRepeaterInfo& existing = _recent_repeaters[i];
|
||||
if (existing.prefix_len != prefix_len || memcmp(existing.prefix, prefix, prefix_len) != 0) {
|
||||
continue;
|
||||
}
|
||||
int16_t lowered = (int16_t)existing.snr_x4 - (int16_t)amount_x4;
|
||||
if (lowered < -128) {
|
||||
lowered = -128;
|
||||
}
|
||||
existing.snr_x4 = (int8_t)lowered;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int getRecentRepeaterCount() const {
|
||||
int count = 0;
|
||||
for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
|
||||
if (_recent_repeaters[i].prefix_len > 0) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
const RecentRepeaterInfo* getRecentRepeaterBySortedIdx(int idx_wanted) const {
|
||||
if (idx_wanted < 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const RecentRepeaterInfo* last = NULL;
|
||||
int last_idx = -1;
|
||||
for (int rank = 0; rank <= idx_wanted; rank++) {
|
||||
const RecentRepeaterInfo* best = NULL;
|
||||
int best_idx = -1;
|
||||
for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
|
||||
const RecentRepeaterInfo* info = &_recent_repeaters[i];
|
||||
if (info->prefix_len == 0) {
|
||||
continue;
|
||||
}
|
||||
if (last != NULL && !recentRepeaterComesBefore(*last, last_idx, *info, i)) {
|
||||
continue;
|
||||
}
|
||||
if (best == NULL || recentRepeaterComesBefore(*info, i, *best, best_idx)) {
|
||||
best = info;
|
||||
best_idx = i;
|
||||
}
|
||||
}
|
||||
if (best == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
last = best;
|
||||
last_idx = best_idx;
|
||||
}
|
||||
return last;
|
||||
}
|
||||
|
||||
const RecentRepeaterInfo* findRecentRepeaterByHash(const uint8_t* hash, uint8_t hash_len) const {
|
||||
if (hash == NULL || hash_len == 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Prefer exact matches. If none exists, fall back to the longest overlapping
|
||||
// prefix, using highest SNR to break ties.
|
||||
const RecentRepeaterInfo* best = NULL;
|
||||
for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
|
||||
const RecentRepeaterInfo* info = &_recent_repeaters[i];
|
||||
if (info->prefix_len == 0) {
|
||||
continue;
|
||||
}
|
||||
if (info->prefix_len == hash_len && memcmp(info->prefix, hash, hash_len) == 0) {
|
||||
return info;
|
||||
}
|
||||
if (prefixesOverlap(info->prefix, info->prefix_len, hash, hash_len)) {
|
||||
if (best == NULL || info->prefix_len > best->prefix_len
|
||||
|| (info->prefix_len == best->prefix_len && info->snr_x4 > best->snr_x4)) {
|
||||
best = info;
|
||||
}
|
||||
}
|
||||
}
|
||||
return best;
|
||||
}
|
||||
void clearRecentRepeaters() {
|
||||
memset(_recent_repeaters, 0, sizeof(_recent_repeaters));
|
||||
}
|
||||
|
||||
void resetStats() { _direct_dups = _flood_dups = 0; }
|
||||
};
|
||||
@@ -16,6 +16,10 @@ public:
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
bool setCodingRate(uint8_t cr) override {
|
||||
return ((CustomLLCC68 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
|
||||
}
|
||||
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomLLCC68 *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -16,6 +16,10 @@ public:
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
bool setCodingRate(uint8_t cr) override {
|
||||
return ((CustomLR1110 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
|
||||
}
|
||||
|
||||
void doResetAGC() override { lr11x0ResetAGC((LR11x0 *)_radio, ((CustomLR1110 *)_radio)->getFreqMHz()); }
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomLR1110 *)_radio)->isReceiving();
|
||||
|
||||
@@ -17,6 +17,10 @@ public:
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
bool setCodingRate(uint8_t cr) override {
|
||||
return ((CustomSTM32WLx *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
|
||||
}
|
||||
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomSTM32WLx *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -20,6 +20,10 @@ public:
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
bool setCodingRate(uint8_t cr) override {
|
||||
return ((CustomSX1262 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
|
||||
}
|
||||
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomSX1262 *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -20,6 +20,10 @@ public:
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
bool setCodingRate(uint8_t cr) override {
|
||||
return ((CustomSX1268 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
|
||||
}
|
||||
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomSX1268 *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -19,6 +19,10 @@ public:
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
bool setCodingRate(uint8_t cr) override {
|
||||
return ((CustomSX1276 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
|
||||
}
|
||||
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomSX1276 *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -40,6 +40,8 @@ public:
|
||||
}
|
||||
|
||||
virtual void setParams(float freq, float bw, uint8_t sf, uint8_t cr) = 0;
|
||||
uint16_t getDefaultPreambleLength() const override { return preambleLengthForSF(_preamble_sf); }
|
||||
bool setPreambleLength(uint16_t len) override { return _radio->setPreambleLength(len) == RADIOLIB_ERR_NONE; }
|
||||
uint32_t getRngSeed();
|
||||
void setTxPower(int8_t dbm);
|
||||
|
||||
|
||||
@@ -8,6 +8,12 @@
|
||||
#define TELEM_WIRE &Wire // Use default I2C bus for Environment Sensors
|
||||
#endif
|
||||
|
||||
bool EnvironmentSensorManager::i2c_probe(TwoWire& wire, uint8_t addr) {
|
||||
wire.beginTransmission(addr);
|
||||
uint8_t error = wire.endTransmission();
|
||||
return error == 0;
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Sensor library includes and static driver instances
|
||||
// ============================================================
|
||||
|
||||
Reference in new issue
Block a user