Merge remote-tracking branch 'upstream/dev' into feat/kiss-agc-fem-control
This commit is contained in:
commit
c0ccb9c7ff
123 files changed
+2095
-396
No files matched your search
@@ -0,0 +1,472 @@
|
||||
# Companion CLI
|
||||
|
||||
Since version 1.18 meshcore companion radio firmware has a CLI interface, which can be accessed locally (through companion radio protocol) or remotely via the network.
|
||||
|
||||
## Navigation
|
||||
- [Operational](#operational)
|
||||
- [Configuration](#configuration)
|
||||
- [System](#system)
|
||||
- [Radio](#radio)
|
||||
- [BLE](#ble)
|
||||
- [Wifi](#wifi)
|
||||
- [UI](#ui)
|
||||
|
||||
## Operational
|
||||
|
||||
### Reboot the node
|
||||
**Usage:**
|
||||
- `reboot`
|
||||
|
||||
**Note:** No reply is sent.
|
||||
|
||||
---
|
||||
|
||||
### Power-off the node
|
||||
**Usage:**
|
||||
- `poweroff`, or
|
||||
- `shutdown`
|
||||
|
||||
**Note:** No reply is sent.
|
||||
|
||||
---
|
||||
|
||||
## Configuration
|
||||
|
||||
### System
|
||||
|
||||
#### View or change this node's name
|
||||
**Usage:**
|
||||
- `get name`
|
||||
- `set name <name>`
|
||||
|
||||
**Parameters:**
|
||||
- `name`: Node name
|
||||
|
||||
**Set by build flag:** `ADVERT_NAME`
|
||||
|
||||
**Default:** Varies by board
|
||||
|
||||
**Note:** Advertised names can use up to 23 bytes when location is included and 31 bytes otherwise. Emoji and Unicode characters may take more than one byte. Names that exceed the available advert space are truncated at a valid UTF-8 code point boundary.
|
||||
|
||||
---
|
||||
|
||||
#### View this node's firmware version
|
||||
**Usage:** `ver`
|
||||
|
||||
---
|
||||
|
||||
#### Configure this node's timezone
|
||||
**Usage:**
|
||||
- `set tz.offset <offset>`
|
||||
- `get tz.offset`
|
||||
|
||||
**Parameters:**
|
||||
- `offset`: float value of the offset in hours
|
||||
|
||||
---
|
||||
|
||||
### Radio
|
||||
|
||||
Radio parameters are common to all roles and handled by `CommonRadioPrefs`.
|
||||
|
||||
#### View or change this node's radio parameters
|
||||
**Usage:**
|
||||
- `get radio`
|
||||
- `set radio <freq>,<bw>,<sf>,<cr>`
|
||||
|
||||
**Parameters:**
|
||||
- `freq`: Frequency in MHz
|
||||
- `bw`: Bandwidth in kHz
|
||||
- `sf`: Spreading factor (5-12)
|
||||
- `cr`: Coding rate (5-8)
|
||||
|
||||
**Set by build flag:** `LORA_FREQ`, `LORA_BW`, `LORA_SF`, `LORA_CR`
|
||||
|
||||
**Default:** `869.618,62.5,8,5`
|
||||
|
||||
**Note:** Requires reboot to apply
|
||||
|
||||
---
|
||||
|
||||
#### View or change this node's transmit power
|
||||
**Usage:**
|
||||
- `get tx`
|
||||
- `set tx <dbm>`
|
||||
|
||||
**Parameters:**
|
||||
- `dbm`: Power level in dBm (1-22)
|
||||
|
||||
**Set by build flag:** `LORA_TX_POWER`
|
||||
|
||||
**Default:** Varies by board
|
||||
|
||||
**Notes:** This setting only controls the power level of the LoRa chip. Some nodes have an additional power amplifier stage which increases the total output. Refer to the node's manual for the correct setting to use. **Setting a value too high may violate the laws in your country.**
|
||||
|
||||
---
|
||||
|
||||
#### View or change this node's frequency
|
||||
**Usage:**
|
||||
- `get freq`
|
||||
- `set freq <frequency>`
|
||||
|
||||
**Parameters:**
|
||||
- `frequency`: Frequency in MHz
|
||||
|
||||
**Default:** `869.618`
|
||||
|
||||
**Note:** Requires reboot to apply
|
||||
**Serial Only:** `set freq <frequency>`
|
||||
|
||||
---
|
||||
|
||||
#### View or change this node's rx boosted gain mode (SX12xx and LR1110)
|
||||
**Usage:**
|
||||
- `get radio.rxgain`
|
||||
- `set radio.rxgain <state>`
|
||||
|
||||
**Parameters:**
|
||||
- `state`: `on`|`off`
|
||||
|
||||
**Default:** `on`
|
||||
|
||||
---
|
||||
|
||||
#### View or change the LoRa FEM receive-path gain state on supported boards
|
||||
**Usage:**
|
||||
- `get radio.fem.rxgain`
|
||||
- `set radio.fem.rxgain <state>`
|
||||
|
||||
**Parameters:**
|
||||
- `state`: `on`|`off`
|
||||
|
||||
**Notes:**
|
||||
- This controls the external LoRa FEM receive-path LNA where the board supports it.
|
||||
- This is separate from `radio.rxgain`, which controls the radio chip receive gain mode.
|
||||
|
||||
---
|
||||
|
||||
#### View or change the LoRa FEM transmit-path gain state on supported boards
|
||||
**Usage:**
|
||||
- `get radio.fem.txgain`
|
||||
- `set radio.fem.txgain <state>`
|
||||
|
||||
**Parameters:**
|
||||
- `state`: `on`|`off`
|
||||
|
||||
**Notes:**
|
||||
- This controls a software-selectable external LoRa FEM transmit gain where the board supports it.
|
||||
- On Station G3, remove the PA PL1 jumper to allow software control. `on` selects PA PL1 high/short and `off` selects PA PL1 low/open. The PA PL2 hardware jumper determines whether this switches between power levels 1/3 or 2/4.
|
||||
- Select an operating level and SX1262 transmit power that comply with local RF limits and the Station G3 power-supply requirements.
|
||||
- The setting is saved immediately, but on Station G3 the level is applied to the hardware at the start of the next transmit, so that the PA supply rail is never re-targeted while the PA is being driven. `get` reports the configured state, which may lead the hardware until the node next transmits.
|
||||
|
||||
---
|
||||
|
||||
#### View or change the duty cycle limit
|
||||
**Usage:**
|
||||
- `get dutycycle`
|
||||
- `set dutycycle <value>`
|
||||
|
||||
**Parameters:**
|
||||
- `value`: Duty cycle percentage (1-100)
|
||||
|
||||
**Default:** `50%` (equivalent to airtime factor 1.0)
|
||||
|
||||
**Examples:**
|
||||
- `set dutycycle 100` — no duty cycle limit
|
||||
- `set dutycycle 50` — 50% duty cycle (default)
|
||||
- `set dutycycle 10` — 10% duty cycle
|
||||
- `set dutycycle 1` — 1% duty cycle (strictest EU requirement)
|
||||
|
||||
> **Note:** Added in firmware v1.15.0
|
||||
|
||||
---
|
||||
|
||||
#### View or change the airtime factor (duty cycle limit)
|
||||
> **Deprecated** as of firmware v1.15.0. Use [`get/set dutycycle`](#view-or-change-the-duty-cycle-limit) instead.
|
||||
|
||||
**Usage:**
|
||||
- `get af`
|
||||
- `set af <value>`
|
||||
|
||||
**Parameters:**
|
||||
- `value`: Airtime factor (0-9). After each transmission, the repeater enforces a silent period of approximately the on-air transmission time multiplied by the value. This results in a long-term duty cycle of roughly 1 divided by (1 plus the value). For example:
|
||||
- `af = 1` → ~50% duty
|
||||
- `af = 2` → ~33% duty
|
||||
- `af = 3` → ~25% duty
|
||||
- `af = 9` → ~10% duty
|
||||
You are responsible for choosing a value that is appropriate for your jurisdiction and channel plan (for example EU 868 Mhz 10% duty cycle regulation).
|
||||
|
||||
**Default:** `1.0`
|
||||
|
||||
---
|
||||
|
||||
#### View or change the local interference threshold
|
||||
**Usage:**
|
||||
- `get int.thresh`
|
||||
- `set int.thresh <value>`
|
||||
|
||||
**Parameters:**
|
||||
- `value`: Interference threshold value
|
||||
|
||||
**Default:** `0.0`
|
||||
|
||||
---
|
||||
|
||||
#### Enable or disable hardware Channel Activity Detection (CAD)
|
||||
**Usage:**
|
||||
- `get cad`
|
||||
- `set cad <on|off>`
|
||||
|
||||
**Description:** When enabled, the radio performs a hardware Channel Activity Detection scan before transmitting and defers if the channel is busy. Runs independently of `int.thresh` — either, both, or none may be active.
|
||||
|
||||
**Parameters:**
|
||||
- `on|off`: Enable or disable hardware CAD
|
||||
|
||||
**Default:** `off`
|
||||
|
||||
---
|
||||
|
||||
#### View or change the AGC Reset Interval
|
||||
**Usage:**
|
||||
- `get agc.reset.interval`
|
||||
- `set agc.reset.interval <value>`
|
||||
|
||||
**Parameters:**
|
||||
- `value`: Interval in seconds, 0-1020, rounded down to a multiple of 4 (17 becomes 16). 0 to disable.
|
||||
|
||||
**Default:** `0.0`
|
||||
|
||||
---
|
||||
|
||||
#### Enable or disable Multi-Acks support
|
||||
**Usage:**
|
||||
- `get multi.acks`
|
||||
- `set multi.acks <state>`
|
||||
|
||||
**Parameters:**
|
||||
- `state`: `0` (disable) or `1` (enable)
|
||||
|
||||
**Default:** `0`
|
||||
|
||||
---
|
||||
|
||||
#### View or change this node's advert path hash size
|
||||
**Usage:**
|
||||
- `get path.hash.mode`
|
||||
- `set path.hash.mode <value>`
|
||||
|
||||
**Parameters:**
|
||||
- `value`: Path hash size (0-2)
|
||||
- `0`: 1 Byte hash size (256 unique ids)[64 max flood]
|
||||
- `1`: 2 Byte hash size (65,536 unique ids)[32 max flood]
|
||||
- `2`: 3 Byte hash size (16,777,216 unique ids)[21 max flood]
|
||||
- `3`: DO NOT USE (Reserved)
|
||||
|
||||
**Default:** `0`
|
||||
|
||||
**Note:** the 'path.hash.mode' sets the low-level ID/hash encoding size used when the repeater adverts. This setting has no impact on what packet ID/hash size this repeater forwards, all sizes should be forwarded on firmware >= 1.14. This feature was added in firmware 1.14
|
||||
#### View or change the retransmit delay factor for flood traffic
|
||||
**Usage:**
|
||||
- `get txdelay`
|
||||
- `set txdelay <value>`
|
||||
|
||||
**Parameters:**
|
||||
- `value`: Transmit delay factor (0-2)
|
||||
|
||||
**Default:** `0.5`
|
||||
|
||||
**Note:** When multiple nearby repeaters all hear the same flood packet, each waits a random amount of time before retransmitting to avoid simultaneous collisions. This factor scales the size of that random window. Higher values reduce collision risk at the cost of added latency. `0` disables the window entirely.
|
||||
|
||||
---
|
||||
|
||||
#### View or change the retransmit delay factor for direct traffic
|
||||
**Usage:**
|
||||
- `get direct.txdelay`
|
||||
- `set direct.txdelay <value>`
|
||||
|
||||
**Parameters:**
|
||||
- `value`: Direct transmit delay factor (0-2)
|
||||
|
||||
**Default:** `0.3` (Repeater) - `0.2` (Room Server, Sensor)
|
||||
|
||||
**Note:** Same collision-avoidance random window as `txdelay`, but applied to direct (non-flood, routed) traffic. The default is lower because direct packets are addressed to a specific next hop, so far fewer nodes compete to retransmit them.
|
||||
|
||||
---
|
||||
|
||||
#### [Experimental] View or change the processing delay for received traffic
|
||||
**Usage:**
|
||||
- `get rxdelay`
|
||||
- `set rxdelay <value>`
|
||||
|
||||
**Parameters:**
|
||||
- `value`: Receive delay base (0-20)
|
||||
|
||||
**Default:** `0.0`
|
||||
|
||||
**Note:** When enabled, repeaters that received a flood packet with a weak signal are held in a delay queue before processing, while those that received it with a strong signal process it immediately. This gives strong-signal paths forwarding priority. By the time weak-signal nodes process their copy, the packet may have already propagated and will be suppressed as a duplicate, reducing redundant retransmissions.
|
||||
|
||||
---
|
||||
|
||||
### BLE
|
||||
|
||||
#### Change BLE PIN
|
||||
**Usage:**
|
||||
- `set pin <pin>`
|
||||
|
||||
**Parameters:**
|
||||
- `pin`: New BLE PIN
|
||||
|
||||
**Set by build flag:** `BLE_PIN_CODE`
|
||||
|
||||
---
|
||||
|
||||
### Wifi
|
||||
|
||||
#### Get status
|
||||
**Usage:**
|
||||
- `get wifi.status`
|
||||
- `get wifi.ip`
|
||||
|
||||
---
|
||||
|
||||
#### Toggle
|
||||
**Usage:**
|
||||
- `set wifi.enabled <value>`
|
||||
- `get wifi.enabled`
|
||||
|
||||
**Parameters:**
|
||||
- `value`: `0` (disable) or `1` (enable)
|
||||
|
||||
---
|
||||
|
||||
#### Set SSID
|
||||
**Usage:**
|
||||
- `set wifi.ssid <value>`
|
||||
- `get wifi.ssid`
|
||||
|
||||
**Parameters:**
|
||||
- `value`: ssid as a string
|
||||
|
||||
---
|
||||
|
||||
#### Set password
|
||||
**Usage:**
|
||||
- `set wifi.pwd <value>`
|
||||
- `get wifi.pwd`
|
||||
|
||||
**Parameters:**
|
||||
- `value`: password string
|
||||
|
||||
---
|
||||
|
||||
### UI
|
||||
|
||||
#### Show clock
|
||||
**Usage:**
|
||||
- `set ui.show_clock <state>`
|
||||
- `get ui.show_clock`
|
||||
|
||||
**Parameters:**
|
||||
- `state`: `0` (disable) or `1` (enable)
|
||||
|
||||
**Default:** `0` (or `UI_SHOW_CLOCK` build flag)
|
||||
|
||||
---
|
||||
|
||||
#### Node discovery screen shows nodes names
|
||||
**Usage:**
|
||||
- `set ui.nd_name <state>`
|
||||
- `get ui.nd_name`
|
||||
|
||||
**Parameters:**
|
||||
- `state`: `1` (show name) or `0` (show pubkey_prefix)
|
||||
|
||||
**Default:** `1`
|
||||
|
||||
**Note:** When showing name, there is not always enough space to draw both incoming and outgoing snr values.
|
||||
|
||||
---
|
||||
|
||||
#### Auto-off screen
|
||||
**Usage:**
|
||||
- `set ui.auto_off_delay <delay>`
|
||||
- `get ui.auto_off_delay`
|
||||
|
||||
**Parameters:**
|
||||
- `delay`: in seconds (`0` means always on)
|
||||
|
||||
**Default:** `15` (or set by `AUTO_OFF_MILLIS` build flag (in ms))
|
||||
|
||||
**Note:**
|
||||
On e-ink displays, when turned off, the screen is not necessarily blanked, see `ui.auto_off_blank` and `ui.backlight_delay`.
|
||||
|
||||
When screen is not blanked, it is not refreshed any more. To let the user aware of that, a sleep icon is shown.
|
||||
|
||||
---
|
||||
|
||||
#### Display backlight timeout
|
||||
**Usage:**
|
||||
- `set ui.backlight_delay <delay>`
|
||||
- `get ui.backlight_delay`
|
||||
|
||||
**Parameters:**
|
||||
- `delay`: in seconds
|
||||
- `0` means no timeout
|
||||
- `-2` means always off
|
||||
- `-1` means always on
|
||||
|
||||
**Note:**
|
||||
When set to `0`, backlight can only be triggered using backlight btn.
|
||||
|
||||
---
|
||||
|
||||
#### When to turn backlight on
|
||||
**Usage:**
|
||||
- `set ui.backlight_on_keys <state>`
|
||||
- `get ui.backlight_on_keys`
|
||||
- `set ui.backlight_on_msgs <state>`
|
||||
- `get ui.backlight_on_msgs`
|
||||
|
||||
**Parameters:**
|
||||
- `state`: `0` (disable) or `1` (enable)
|
||||
|
||||
**Default:**
|
||||
- `ui.backlight_on_msgs = 0`
|
||||
- `ui.backlight_on_keys = 0` if there is a backlight button on the board, else `1`
|
||||
|
||||
**Note:**
|
||||
By default backlight is triggered by backlight button if present (as long as the button is pressed backlight is on, and is turned off after a delay).
|
||||
These toggles permits to toggle backlight when keys are pressed or when a message arrives (it acts as a notification signal).
|
||||
If `backlight_delay` is set to `0` then this setting has no effect, backlight won't be turned on.
|
||||
|
||||
---
|
||||
|
||||
#### Control if eink screen should be blanked
|
||||
**Usage:**
|
||||
- `set ui.auto_off_blank <state>`
|
||||
- `get ui.auto_off_blank`
|
||||
|
||||
**Parameters:**
|
||||
- `state`: `0` (disable) or `1` (enable)
|
||||
|
||||
**Default:** `0` (or set by `UI_SCREENOFF_BLANK` build flag)
|
||||
|
||||
**Note:**
|
||||
If disabled, when screen is shut the displays stays on screen and is not updated (an sleep icons covers battery to show the screen is sleeping).
|
||||
|
||||
When screen is blanked, the controller is also put into hibernation, which should preserve the screen a little and some battery ...
|
||||
|
||||
---
|
||||
|
||||
#### Maximum number of partial refreshes
|
||||
**Usage:**
|
||||
- `set ui.max_partial <value>`
|
||||
- `get ui.max_partial`
|
||||
|
||||
**Parmeters:**
|
||||
- `value`: max partial refreshes before doing a full refresh
|
||||
|
||||
**Default:** 0 (no partial refresh or set by `EINK_MAX_PARTIAL_REFRESH` build flag)
|
||||
|
||||
**Note:**
|
||||
Forcing full refresh helps revives the screen when some tearing appears (under certain environmental conditions). If you see some tearing appearing, you can force full refresh on your screen manually by double clicking the backlight button. If tearing reappears often, use this setting to force full refresh every `value` partial refreshes.
|
||||
@@ -19,6 +19,8 @@ Once you have a working app/project, you need to be able to demonstrate it exist
|
||||
| 0110 - 011F | Ripple | ripple_biz@protonmail.com — https://buymeacoffee.com/ripplebiz |
|
||||
| 0120 | MCO Advanced | most.original.address@gmail.com — https://hdden.ru/MCOa/ |
|
||||
| 0130 - 013F | StreamSensor | william@housedillon.com - https://housedillon.com/blog/lora-e5-with-seeed-fusion |
|
||||
| 0140 | Nelos | support@nelos.app — https://nelos.app |
|
||||
| 0150 | Road Events | juraj@bednar.io — https://github.com/jooray/roadbeacon/blob/main/nips/road-events.md |
|
||||
| FF00 - FFFF | -reserved for testing/dev- | |
|
||||
|
||||
(add rows, inside the range 0100 - FEFF for custom apps)
|
||||
@@ -758,8 +758,21 @@ void MyMesh::onContactResponse(const ContactInfo &contact, const uint8_t *data,
|
||||
memcpy(&out_frame[i], &data[4], len - 4);
|
||||
i += (len - 4);
|
||||
_serial->writeFrame(out_frame, i);
|
||||
} else if (_listener && len > 4) {
|
||||
_listener->onUnhandledResponse(contact, tag, &data[4], len - 4);
|
||||
} else {
|
||||
bool handled;
|
||||
if (_listener && len > 4) {
|
||||
handled = _listener->onUnhandledResponse(contact, tag, &data[4], len - 4);
|
||||
} else {
|
||||
handled = false;
|
||||
}
|
||||
if (!handled) { // let the app know about unknown/unhandled responses (eg. push telemetry packets)
|
||||
int i = 0;
|
||||
out_frame[i++] = PUSH_CODE_BINARY_RESPONSE;
|
||||
out_frame[i++] = 0; // reserved
|
||||
memcpy(&out_frame[i], data, len);
|
||||
i += len;
|
||||
_serial->writeFrame(out_frame, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1162,7 +1175,9 @@ void MyMesh::handleCmdFrame(size_t len) {
|
||||
? ERR_CODE_NOT_FOUND
|
||||
: ERR_CODE_UNSUPPORTED_CMD); // unknown recipient, or unsupported TXT_TYPE_*
|
||||
}
|
||||
} else if (cmd_frame[0] == CMD_SEND_CHANNEL_TXT_MSG) { // send GroupChannel text msg
|
||||
} else if (cmd_frame[0] == CMD_SEND_CHANNEL_TXT_MSG && len >= 7) { // send GroupChannel text msg
|
||||
// 7 = code, txt_type, channel_idx and the 4 byte timestamp; the text may be empty.
|
||||
// Without this the text length below is computed as len - 7 and turns negative.
|
||||
int i = 1;
|
||||
uint8_t txt_type = cmd_frame[i++]; // should be TXT_TYPE_PLAIN
|
||||
uint8_t channel_idx = cmd_frame[i++];
|
||||
@@ -2109,6 +2124,23 @@ bool MyMesh::handleCommand(const char* command, uint32_t sender_timestamp, char*
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef PIN_BUZZER
|
||||
if (strcmp(command, "get buzzer") == 0) {
|
||||
sprintf(reply, "> %s", _prefs.buzzer_quiet ? "off" : "on");
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "set buzzer ", 11) == 0) {
|
||||
if (strcmp(&command[11], "on") == 0 || strcmp(&command[11], "off") == 0) {
|
||||
_prefs.buzzer_quiet = strcmp(&command[11], "off") == 0;
|
||||
savePrefs();
|
||||
strcpy(reply, "OK");
|
||||
} else {
|
||||
strcpy(reply, "Error: state must be on or off");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (memcmp(command, "set pin ", 8) == 0) {
|
||||
_prefs.ble_pin = atoi(&command[8]);
|
||||
savePrefs();
|
||||
@@ -2179,11 +2211,12 @@ bool MyMesh::handleCommand(const char* command, uint32_t sender_timestamp, char*
|
||||
}
|
||||
|
||||
if (strcmp(command, "get tz.offset") == 0) {
|
||||
sprintf(reply, "> %d", _prefs.tz_offset);
|
||||
float q = _prefs.tz_offset * 4;
|
||||
sprintf(reply, (q == (int)q && ((int)q & 1)) ? "> %.2f" : "> %.1f", _prefs.tz_offset);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "set tz.offset ", 14) == 0) {
|
||||
int8_t tz = atof(&command[14]);
|
||||
float tz = atof(&command[14]);
|
||||
if (tz < -12 || tz > 14) {
|
||||
strcpy(reply, "Error, must be from -12 to +14");
|
||||
} else {
|
||||
@@ -2193,6 +2226,108 @@ bool MyMesh::handleCommand(const char* command, uint32_t sender_timestamp, char*
|
||||
}
|
||||
return true;
|
||||
}
|
||||
#ifdef DISPLAY_CLASS
|
||||
if (memcmp(command, "set ui.show_clock", 17) == 0) {
|
||||
_prefs.ui_show_clock = atoi(&command[17]) ? 1 : 0;
|
||||
savePrefs();
|
||||
sprintf(reply, "> now %d", _prefs.ui_show_clock);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "set ui.auto_off_delay", 21) == 0) {
|
||||
_prefs.ui_auto_off_delay = atoi(&command[21]);
|
||||
savePrefs();
|
||||
sprintf(reply, "> now %d seconds", _prefs.ui_auto_off_delay);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "set ui.backlight_delay", 22) == 0) {
|
||||
_prefs.ui_backlight_delay = atoi(&command[22]);
|
||||
savePrefs();
|
||||
if (_prefs.ui_backlight_delay >= 0)
|
||||
sprintf(reply, "> now %d seconds", _prefs.ui_backlight_delay);
|
||||
else if (_prefs.ui_backlight_delay == -1)
|
||||
sprintf(reply, "> now always on (-1)");
|
||||
else
|
||||
sprintf(reply, "> now disabled (<-1)");
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "set ui.backlight_on_keys", 24) == 0) {
|
||||
_prefs.ui_backlight_on_keys = atoi(&command[24]);
|
||||
savePrefs();
|
||||
sprintf(reply, "> now %d", _prefs.ui_backlight_on_keys);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "set ui.backlight_on_msgs", 24) == 0) {
|
||||
_prefs.ui_backlight_on_msgs = atoi(&command[24]);
|
||||
savePrefs();
|
||||
sprintf(reply, "> now %d", _prefs.ui_backlight_on_msgs);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "set ui.auto_off_blank", 21) == 0) {
|
||||
_prefs.ui_auto_off_blank = atoi(&command[21]);
|
||||
savePrefs();
|
||||
sprintf(reply, "> now %d", _prefs.ui_auto_off_blank);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "set ui.auto_off_keep_msgs", 25) == 0) {
|
||||
_prefs.ui_auto_off_keep_msgs = atoi(&command[25]);
|
||||
savePrefs();
|
||||
sprintf(reply, "> now %d", _prefs.ui_auto_off_keep_msgs);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "set ui.max_partial", 18) == 0) {
|
||||
_prefs.ui_max_partial = atoi(&command[18]);
|
||||
savePrefs();
|
||||
sprintf(reply, "> now %d (applied at next screen wakeup)", _prefs.ui_max_partial);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "set ui.nd_name", 14) == 0) {
|
||||
_prefs.ui_nd_name = atoi(&command[14]);
|
||||
savePrefs();
|
||||
sprintf(reply, "> ui.nd_name is now %d", _prefs.ui_nd_name);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "get ui.show_clock", 17) == 0) {
|
||||
sprintf(reply, "> %d", _prefs.ui_show_clock);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "get ui.auto_off_delay", 21) == 0) {
|
||||
sprintf(reply, "> %d seconds", _prefs.ui_auto_off_delay);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "get ui.backlight_delay", 22) == 0) {
|
||||
if (_prefs.ui_backlight_delay >= 0)
|
||||
sprintf(reply, "> %d seconds", _prefs.ui_backlight_delay);
|
||||
else if (_prefs.ui_backlight_delay == -1)
|
||||
sprintf(reply, "> always on (-1)");
|
||||
else
|
||||
sprintf(reply, "> disabled (<-1)");
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "get ui.backlight_on_keys", 24) == 0) {
|
||||
sprintf(reply, "> %d", _prefs.ui_backlight_on_keys);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "get ui.backlight_on_msgs", 24) == 0) {
|
||||
sprintf(reply, "> %d", _prefs.ui_backlight_on_msgs);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "get ui.auto_off_blank", 21) == 0) {
|
||||
sprintf(reply, "> %d", _prefs.ui_auto_off_blank);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "get ui.auto_off_keep_msgs", 25) == 0) {
|
||||
sprintf(reply, "> %d", _prefs.ui_auto_off_keep_msgs);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "get ui.max_partial", 18) == 0) {
|
||||
sprintf(reply, "> %d", _prefs.ui_max_partial);
|
||||
return true;
|
||||
}
|
||||
if (memcmp(command, "get ui.nd_name", 14) == 0) {
|
||||
sprintf(reply, "> %d", _prefs.ui_nd_name);
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
return false; // not handled
|
||||
}
|
||||
|
||||
@@ -7,11 +7,11 @@
|
||||
#define FIRMWARE_VER_CODE 14
|
||||
|
||||
#ifndef FIRMWARE_BUILD_DATE
|
||||
#define FIRMWARE_BUILD_DATE "14 Aug 2026"
|
||||
#define FIRMWARE_BUILD_DATE "15 Oct 2026"
|
||||
#endif
|
||||
|
||||
#ifndef FIRMWARE_VERSION
|
||||
#define FIRMWARE_VERSION "v1.17.1"
|
||||
#define FIRMWARE_VERSION "v1.18.0"
|
||||
#endif
|
||||
|
||||
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
|
||||
@@ -101,7 +101,7 @@ public:
|
||||
virtual void onACKRecv(uint32_t ack_crc) { }
|
||||
virtual uint8_t onUnhandledRequest(const ContactInfo &contact, uint32_t sender_timestamp, const uint8_t *data,
|
||||
uint8_t len, uint8_t *reply) { return 0; /* unknown request type */ }
|
||||
virtual void onUnhandledResponse(const ContactInfo &from, uint32_t tag, const uint8_t* data, uint8_t len) { }
|
||||
virtual bool onUnhandledResponse(const ContactInfo &from, uint32_t tag, const uint8_t* data, uint8_t len) { return false; /* not handled */ }
|
||||
virtual void onTraceRecv(mesh::Packet *pkt, uint32_t tag, uint32_t auth_code, uint8_t flags,
|
||||
const uint8_t *path_snrs, const uint8_t *path_hashes, uint8_t path_len) { }
|
||||
virtual void onRawDataRecv(mesh::Packet *pkt) { }
|
||||
|
||||
@@ -47,7 +47,7 @@ public:
|
||||
uint8_t agc_reset_interval = 0; // secs / 4
|
||||
char default_scope_name[31];
|
||||
uint8_t default_scope_key[16];
|
||||
int8_t tz_offset = 0;
|
||||
float tz_offset = 0;
|
||||
#ifdef ENABLE_WIFI_INTERFACE
|
||||
#ifndef WIFI_SSID
|
||||
#define WIFI_SSID ""
|
||||
@@ -58,6 +58,34 @@ public:
|
||||
// use ssid from prefs, or fallback to ssid from build flags
|
||||
const char* getWifiSSID() const { return wifi_ssid[0] ? wifi_ssid : WIFI_SSID; }
|
||||
#endif
|
||||
#ifdef DISPLAY_CLASS
|
||||
#ifndef UI_SHOW_CLOCK
|
||||
#define UI_SHOW_CLOCK 0
|
||||
#endif
|
||||
#ifndef AUTO_OFF_MILLIS
|
||||
#define AUTO_OFF_MILLIS 15000
|
||||
#endif
|
||||
#ifndef EINK_MAX_PARTIAL_REFRESH
|
||||
#define EINK_MAX_PARTIAL_REFRESH 0
|
||||
#endif
|
||||
uint8_t ui_show_clock = UI_SHOW_CLOCK;
|
||||
uint32_t ui_auto_off_delay = AUTO_OFF_MILLIS / 1000;
|
||||
int32_t ui_backlight_delay = 5;
|
||||
#if defined(BACKLIGHT_BTN)
|
||||
uint8_t ui_backlight_on_keys = 0;
|
||||
#else
|
||||
uint8_t ui_backlight_on_keys = 1;
|
||||
#endif
|
||||
uint8_t ui_backlight_on_msgs = 0;
|
||||
#ifdef UI_SCREENOFF_BLANK
|
||||
uint8_t ui_auto_off_blank = 1;
|
||||
#else
|
||||
uint8_t ui_auto_off_blank = 0;
|
||||
#endif
|
||||
uint8_t ui_auto_off_keep_msgs = 1;
|
||||
uint8_t ui_max_partial = EINK_MAX_PARTIAL_REFRESH;
|
||||
uint8_t ui_nd_name = 1;
|
||||
#endif
|
||||
|
||||
private:
|
||||
class RadioPrefs : public CommonRadioPrefs {
|
||||
@@ -102,8 +130,8 @@ private:
|
||||
void setIntThresh(uint8_t t) override { _parent->interference_threshold = t; markDirty(); }
|
||||
uint8_t getRxGain() const override { return _parent->rx_boosted_gain; }
|
||||
void setRxGain(uint8_t g) override { _parent->rx_boosted_gain = g; markDirty(); }
|
||||
uint8_t getTxPower() const override { return _parent->tx_power_dbm; }
|
||||
void setTxPower(uint8_t dbm) override { _parent->tx_power_dbm = dbm; markDirty(); }
|
||||
int8_t getTxPower() const override { return _parent->tx_power_dbm; }
|
||||
void setTxPower(int8_t dbm) override { _parent->tx_power_dbm = dbm; markDirty(); }
|
||||
float getRxDelay() const override { return _parent->rx_delay_base; }
|
||||
void setRxDelay(float d) override { _parent->rx_delay_base = d; markDirty(); }
|
||||
uint16_t getAgcResetInt() const override { return _parent->agc_reset_interval * 4; }
|
||||
@@ -189,6 +217,27 @@ private:
|
||||
WiFiPrefs wifi;
|
||||
#endif
|
||||
|
||||
#ifdef DISPLAY_CLASS
|
||||
class UI_Prefs : public ConfigSerializer {
|
||||
NodePrefs* _parent;
|
||||
protected:
|
||||
void structure() override {
|
||||
def("show_clock", _parent->ui_show_clock);
|
||||
def("auto_off", _parent->ui_auto_off_delay);
|
||||
def("bl_dly", _parent->ui_backlight_delay);
|
||||
def("bl_keys", _parent->ui_backlight_on_keys);
|
||||
def("bl_msgs", _parent->ui_backlight_on_msgs);
|
||||
def("max_partial", _parent->ui_max_partial);
|
||||
def("off_blank", _parent->ui_auto_off_blank);
|
||||
def("off_keep_msgs", _parent->ui_auto_off_keep_msgs);
|
||||
def("nd_name", _parent->ui_nd_name);
|
||||
}
|
||||
public:
|
||||
UI_Prefs(NodePrefs* parent) : _parent(parent) {}
|
||||
};
|
||||
UI_Prefs ui;
|
||||
#endif
|
||||
|
||||
protected:
|
||||
void structure() override {
|
||||
def("name", node_name, sizeof(node_name));
|
||||
@@ -203,12 +252,18 @@ protected:
|
||||
def("custom", custom);
|
||||
#ifdef ENABLE_WIFI_INTERFACE
|
||||
def("wifi", wifi);
|
||||
#endif
|
||||
#ifdef DISPLAY_CLASS
|
||||
def("ui", ui);
|
||||
#endif
|
||||
}
|
||||
public:
|
||||
NodePrefs() : radio(this), gps(this), companion(this), custom(&radio)
|
||||
#ifdef ENABLE_WIFI_INTERFACE
|
||||
, wifi(this)
|
||||
#endif
|
||||
#ifdef DISPLAY_CLASS
|
||||
, ui(this)
|
||||
#endif
|
||||
{
|
||||
node_name[0] = 0;
|
||||
|
||||
@@ -91,7 +91,9 @@ class HomeScreen : public UIScreen {
|
||||
FIRST,
|
||||
RECENT,
|
||||
RADIO,
|
||||
#ifdef BLE_PIN_CODE
|
||||
BLUETOOTH,
|
||||
#endif
|
||||
ADVERT,
|
||||
#if ENV_INCLUDE_GPS == 1
|
||||
GPS,
|
||||
@@ -120,7 +122,6 @@ class HomeScreen : public UIScreen {
|
||||
uint32_t disc_node_req_tag = 0;
|
||||
uint32_t disc_nodes_count = 0;
|
||||
uint32_t discovery_req_time = 0;
|
||||
bool discovery_disp_names = true; // by default desplay names if available (removes SNR_O)
|
||||
#endif
|
||||
|
||||
void renderBatteryIndicator(DisplayDriver& display, uint16_t batteryMilliVolts) {
|
||||
@@ -195,11 +196,10 @@ class HomeScreen : public UIScreen {
|
||||
sensors_nb ++;
|
||||
}
|
||||
sensors_scroll = sensors_nb > UI_RECENT_LIST_SIZE;
|
||||
#if AUTO_OFF_MILLIS > 0
|
||||
next_sensors_refresh = millis() + 5000; // refresh sensor values every 5 sec
|
||||
#else
|
||||
next_sensors_refresh = millis() + 60000; // refresh sensor values every 1 min
|
||||
#endif
|
||||
if (display.isEink()) // preserve eink displays
|
||||
next_sensors_refresh = millis() + 60000; // refresh sensor values every 1 min
|
||||
else
|
||||
next_sensors_refresh = millis() + 5000; // refresh sensor values every 5 sec
|
||||
}
|
||||
}
|
||||
|
||||
@@ -281,45 +281,51 @@ public:
|
||||
|
||||
if (_page == HomePage::FIRST) {
|
||||
display.setColor(UIColor::primary_txt);
|
||||
#ifdef ENABLE_WIFI_INTERFACE
|
||||
// smaller unread message ui for wifi variants
|
||||
display.setTextSize(1);
|
||||
sprintf(tmp, "Unread Msg: %d", _task->getMsgCount());
|
||||
display.drawTextCentered(display.width() / 2, 22, tmp);
|
||||
#else
|
||||
// larger unread message ui for non wifi variants
|
||||
display.setTextSize(2);
|
||||
sprintf(tmp, "MSG: %d", _task->getMsgCount());
|
||||
display.drawTextCentered(display.width() / 2, 22, tmp);
|
||||
|
||||
#ifdef UI_SHOW_CLOCK
|
||||
display.setTextSize(3);
|
||||
uint32_t now = _rtc->getCurrentTime();
|
||||
now += (int32_t)_node_prefs->tz_offset * 3600;
|
||||
DateTime dt (now);
|
||||
sprintf(tmp, "%02d:%02d", dt.hour(), dt.minute());
|
||||
display.drawTextCentered(display.width() / 2, 60, tmp);
|
||||
display.setTextSize(1);
|
||||
sprintf(tmp, "%02d/%02d/%d", dt.day(), dt.month(), dt.year());
|
||||
display.drawTextCentered(display.width() / 2, 80, tmp);
|
||||
#endif
|
||||
if (_node_prefs->ui_show_clock) {
|
||||
display.setTextSize(3);
|
||||
uint32_t now = _rtc->getCurrentTime();
|
||||
now += (int32_t)(_node_prefs->tz_offset * 3600);
|
||||
DateTime dt (now);
|
||||
sprintf(tmp, "%02d:%02d", dt.hour(), dt.minute());
|
||||
display.drawTextCentered(display.width() / 2, 60, tmp);
|
||||
display.setTextSize(1);
|
||||
sprintf(tmp, "%02d/%02d/%d", dt.day(), dt.month(), dt.year());
|
||||
display.drawTextCentered(display.width() / 2, 80, tmp);
|
||||
}
|
||||
#ifdef ENABLE_WIFI_INTERFACE
|
||||
IPAddress ip = WiFi.localIP();
|
||||
snprintf(tmp, sizeof(tmp), "IP: %d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
|
||||
display.setTextSize(1);
|
||||
display.drawTextCentered(display.width() / 2, 54, tmp);
|
||||
display.drawTextCentered(display.width() / 2, 32, tmp);
|
||||
#endif
|
||||
if (_task->hasConnection()) {
|
||||
display.setColor(UIColor::warning_txt);
|
||||
display.setTextSize(1);
|
||||
#ifdef UI_SHOW_CLOCK
|
||||
display.drawTextCentered(display.width() / 2, 110, "< Connected >");
|
||||
#else
|
||||
display.drawTextCentered(display.width() / 2, 43, "< Connected >");
|
||||
#endif
|
||||
if (_node_prefs->ui_show_clock)
|
||||
display.drawTextCentered(display.width() / 2, 110, "< Connected >");
|
||||
else
|
||||
display.drawTextCentered(display.width() / 2, 43, "< Connected >");
|
||||
} else if (the_mesh.getBLEPin() != 0) { // BT pin
|
||||
display.setColor(UIColor::warning_txt);
|
||||
sprintf(tmp, "Pin:%d", the_mesh.getBLEPin());
|
||||
#ifdef UI_SHOW_CLOCK
|
||||
display.setTextSize(1);
|
||||
display.drawTextCentered(display.width() / 2, 110, tmp);
|
||||
#else
|
||||
display.setTextSize(2);
|
||||
display.drawTextCentered(display.width() / 2, 43, tmp);
|
||||
#endif
|
||||
if (_node_prefs->ui_show_clock) {
|
||||
display.setTextSize(1);
|
||||
display.drawTextCentered(display.width() / 2, 110, tmp);
|
||||
} else {
|
||||
display.setTextSize(2);
|
||||
display.drawTextCentered(display.width() / 2, 43, tmp);
|
||||
}
|
||||
}
|
||||
} else if (_page == HomePage::RECENT) {
|
||||
the_mesh.getRecentlyHeard(recent, UI_RECENT_LIST_SIZE);
|
||||
@@ -365,6 +371,7 @@ public:
|
||||
display.setCursor(0, 53);
|
||||
sprintf(tmp, "Noise floor: %d", radio_driver.getNoiseFloor());
|
||||
display.print(tmp);
|
||||
#ifdef BLE_PIN_CODE
|
||||
} else if (_page == HomePage::BLUETOOTH) {
|
||||
display.setColor(UIColor::corp_blue);
|
||||
display.drawXbm((display.width() - 32) / 2, 18,
|
||||
@@ -373,6 +380,7 @@ public:
|
||||
display.setColor(UIColor::secondary_txt);
|
||||
display.setTextSize(1);
|
||||
display.drawTextCentered(display.width() / 2, 64 - 11, "toggle: " PRESS_LABEL);
|
||||
#endif
|
||||
} else if (_page == HomePage::ADVERT) {
|
||||
display.setColor(UIColor::corp_blue);
|
||||
display.drawXbm((display.width() - 32) / 2, 18, advert_icon, 32, 32);
|
||||
@@ -508,7 +516,7 @@ public:
|
||||
for (int i = 0; i < count; i++, y += 11) {
|
||||
char name[32];
|
||||
auto a = &discovered[i];
|
||||
if ((a->name[0] == 0) || !discovery_disp_names) {
|
||||
if ((a->name[0] == 0) || !_node_prefs->ui_nd_name) {
|
||||
mesh::Utils::toHex(name, a->pubkey_prefix, 4);
|
||||
} else {
|
||||
strncpy(name, a->name, 32);
|
||||
@@ -568,6 +576,7 @@ public:
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
#ifdef BLE_PIN_CODE
|
||||
if (c == KEY_ENTER && _page == HomePage::BLUETOOTH) {
|
||||
if (_task->isBluetoothEnabled()) { // toggle Bluetooth on/off
|
||||
_task->disableBluetooth();
|
||||
@@ -576,6 +585,7 @@ public:
|
||||
}
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
if (c == KEY_ENTER && _page == HomePage::ADVERT) {
|
||||
_task->notify(UIEventType::ack);
|
||||
if (the_mesh.advert()) {
|
||||
@@ -606,7 +616,7 @@ public:
|
||||
return true;
|
||||
}
|
||||
if (c == KEY_SELECT && _page == HomePage::DISCOVERY) {
|
||||
discovery_disp_names = !discovery_disp_names;
|
||||
_node_prefs->ui_nd_name = !_node_prefs->ui_nd_name;
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
@@ -690,11 +700,7 @@ public:
|
||||
display.translateUTF8ToBlocks(filtered_msg, p->msg, sizeof(filtered_msg));
|
||||
display.printWordWrap(filtered_msg, display.width());
|
||||
|
||||
#if AUTO_OFF_MILLIS==0 // probably e-ink
|
||||
return 10000; // 10 s
|
||||
#else
|
||||
return 1000; // next render after 1000 ms
|
||||
#endif
|
||||
return display.isEink() ? 10000 : 1000; // 10 s for eink
|
||||
}
|
||||
|
||||
bool handleInput(char c) override {
|
||||
@@ -718,7 +724,6 @@ public:
|
||||
void UITask::begin(DisplayDriver* display, SensorManager* sensors, NodePrefs* node_prefs) {
|
||||
_display = display;
|
||||
_sensors = sensors;
|
||||
_auto_off = millis() + AUTO_OFF_MILLIS;
|
||||
|
||||
#if defined(PIN_USER_BTN)
|
||||
user_btn.begin();
|
||||
@@ -726,11 +731,16 @@ void UITask::begin(DisplayDriver* display, SensorManager* sensors, NodePrefs* no
|
||||
#if defined(PIN_USER_BTN_ANA)
|
||||
analog_btn.begin();
|
||||
#endif
|
||||
#if defined(BACKLIGHT_BTN)
|
||||
backlight_btn.begin();
|
||||
#endif
|
||||
|
||||
_node_prefs = node_prefs;
|
||||
_auto_off = millis() + _node_prefs->ui_auto_off_delay * 1000;
|
||||
_backlight_off = millis() + _node_prefs->ui_backlight_delay * 1000;
|
||||
|
||||
if (_display != NULL) {
|
||||
_display->turnOn();
|
||||
_display->turnOn(_node_prefs->ui_max_partial);
|
||||
}
|
||||
|
||||
#ifdef PIN_BUZZER
|
||||
@@ -796,11 +806,14 @@ void UITask::onMessageRecv(mesh::Packet *pkt, const ContactInfo &from, uint8_t t
|
||||
|
||||
if (_display != NULL) {
|
||||
if (!_display->isOn() && !hasConnection()) {
|
||||
_display->turnOn();
|
||||
_display->turnOn(_node_prefs->ui_max_partial);
|
||||
}
|
||||
if (_display->isOn()) {
|
||||
_auto_off = millis() + AUTO_OFF_MILLIS; // extend the auto-off timer
|
||||
_next_refresh = 100; // trigger refresh
|
||||
_auto_off = millis() + _node_prefs->ui_auto_off_delay * 1000; // extend the auto-off timer
|
||||
_next_refresh = 100; // trigger refresh
|
||||
if (_node_prefs->ui_backlight_on_msgs) {
|
||||
_backlight_off = millis() + _node_prefs->ui_backlight_delay * 1000;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -816,10 +829,10 @@ void UITask::onChannelMessageRecv(mesh::Packet *pkt, ChannelDetails& channel_det
|
||||
|
||||
if (_display != NULL) {
|
||||
if (!_display->isOn() && !hasConnection()) {
|
||||
_display->turnOn();
|
||||
_display->turnOn(_node_prefs->ui_max_partial);
|
||||
}
|
||||
if (_display->isOn()) {
|
||||
_auto_off = millis() + AUTO_OFF_MILLIS; // extend the auto-off timer
|
||||
_auto_off = millis() + _node_prefs->ui_auto_off_delay * 1000; // extend the auto-off timer
|
||||
_next_refresh = 100; // trigger refresh
|
||||
}
|
||||
}
|
||||
@@ -897,9 +910,9 @@ void UITask::shutdown(bool restart){
|
||||
if (restart) {
|
||||
_board->reboot();
|
||||
} else {
|
||||
display.forceFullRefresh();
|
||||
display.clear();
|
||||
display.endFrame();
|
||||
if (_display->isEink()) {
|
||||
_display->turnOff(true);
|
||||
}
|
||||
// Power off board including radio, display, GPS and components
|
||||
_board->powerOff();
|
||||
}
|
||||
@@ -944,7 +957,7 @@ void UITask::loop() {
|
||||
if (ev == BUTTON_EVENT_CLICK) {
|
||||
c = checkDisplayOn(KEY_ENTER);
|
||||
} else if (ev == BUTTON_EVENT_LONG_PRESS) {
|
||||
display.turnOff();
|
||||
display.turnOff(true);
|
||||
} else if (ev == BUTTON_EVENT_DOUBLE_CLICK) {
|
||||
c = handleDoubleClick(KEY_SELECT);
|
||||
} else if (ev == BUTTON_EVENT_TRIPLE_CLICK) {
|
||||
@@ -964,11 +977,11 @@ void UITask::loop() {
|
||||
#endif
|
||||
#if defined(UI_HAS_ROTARY_INPUT)
|
||||
RotaryInputEvent rotaryEv = rotary_input.poll();
|
||||
if (c == 0 && _display != NULL && _display->isOn()) {
|
||||
if (c == 0 && _display != NULL) {
|
||||
if (rotaryEv == RotaryInputEvent::Next) {
|
||||
c = KEY_NEXT;
|
||||
c = checkDisplayOn(KEY_NEXT);
|
||||
} else if (rotaryEv == RotaryInputEvent::Prev) {
|
||||
c = KEY_PREV;
|
||||
c = checkDisplayOn(KEY_PREV);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -987,27 +1000,59 @@ void UITask::loop() {
|
||||
_analogue_pin_read_millis = millis();
|
||||
}
|
||||
#endif
|
||||
#if defined(DISP_BACKLIGHT) || defined(EXP_PIN_BACKLIGHT)
|
||||
#if defined(BACKLIGHT_BTN)
|
||||
if (millis() > next_backlight_btn_check) {
|
||||
bool touch_state = digitalRead(PIN_BUTTON2);
|
||||
#if defined(DISP_BACKLIGHT)
|
||||
digitalWrite(DISP_BACKLIGHT, !touch_state);
|
||||
#elif defined(EXP_PIN_BACKLIGHT)
|
||||
expander.digitalWrite(EXP_PIN_BACKLIGHT, !touch_state);
|
||||
#endif
|
||||
next_backlight_btn_check = millis() + 300;
|
||||
if (backlight_btn.isPressed()) {
|
||||
if (!_display->isOn()) {
|
||||
_display->turnOn(_node_prefs->ui_max_partial);
|
||||
_next_refresh = 0;
|
||||
}
|
||||
_auto_off = millis() + _node_prefs->ui_auto_off_delay * 1000; // extend auto-off timer
|
||||
_backlight_off = millis() + _node_prefs->ui_backlight_delay * 1000; // extend auto_off for backlight
|
||||
}
|
||||
next_backlight_btn_check = millis() + 100;
|
||||
}
|
||||
int bev = backlight_btn.check();
|
||||
if (bev == BUTTON_EVENT_DOUBLE_CLICK) {
|
||||
_display->forceFullRefresh();
|
||||
} else if (bev == BUTTON_EVENT_TRIPLE_CLICK) {
|
||||
_display->turnOff(true);
|
||||
_backlight_off = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
bool backlight_state;
|
||||
if (_node_prefs->ui_backlight_delay == -1) {
|
||||
backlight_state = true;
|
||||
} else if (_node_prefs->ui_backlight_delay < -1) {
|
||||
backlight_state = false;
|
||||
} else if (_node_prefs->ui_backlight_delay == 0) {
|
||||
backlight_state = false;
|
||||
#ifdef BACKLIGHT_BTN
|
||||
backlight_state = backlight_btn.isPressed();
|
||||
#endif
|
||||
} else {
|
||||
backlight_state = (millis() < _backlight_off);
|
||||
}
|
||||
|
||||
#if defined(DISP_BACKLIGHT)
|
||||
digitalWrite(DISP_BACKLIGHT, backlight_state);
|
||||
#elif defined(EXP_PIN_BACKLIGHT)
|
||||
expander.digitalWrite(EXP_PIN_BACKLIGHT, backlight_state);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (c != 0 && curr) {
|
||||
curr->handleInput(c);
|
||||
_auto_off = millis() + AUTO_OFF_MILLIS; // extend auto-off timer
|
||||
_auto_off = millis() + _node_prefs->ui_auto_off_delay * 1000; // extend auto-off timer
|
||||
_next_refresh = 100; // trigger refresh
|
||||
}
|
||||
|
||||
userLedHandler();
|
||||
|
||||
#ifdef PIN_BUZZER
|
||||
if (buzzer.isQuiet() != (bool)_node_prefs->buzzer_quiet) buzzer.quiet(_node_prefs->buzzer_quiet);
|
||||
if (buzzer.isPlaying()) buzzer.loop();
|
||||
#endif
|
||||
|
||||
@@ -1032,20 +1077,27 @@ void UITask::loop() {
|
||||
}
|
||||
_display->endFrame();
|
||||
}
|
||||
#if AUTO_OFF_MILLIS > 0
|
||||
if (_node_prefs->ui_auto_off_delay > 0) {
|
||||
#ifdef KEEP_DISPLAY_ON_USB
|
||||
// Opt-in: refresh the auto-off deadline while externally powered, so the
|
||||
// timer counts from the moment external power is removed. Off by default
|
||||
// because OLED panels burn in quickly; only enable for LCD targets or
|
||||
// where the display is replaceable.
|
||||
if (board.isExternalPowered()) {
|
||||
_auto_off = millis() + AUTO_OFF_MILLIS;
|
||||
}
|
||||
// Opt-in: refresh the auto-off deadline while externally powered, so the
|
||||
// timer counts from the moment external power is removed. Off by default
|
||||
// because OLED panels burn in quickly; only enable for LCD targets or
|
||||
// where the display is replaceable.
|
||||
if (board.isExternalPowered()) {
|
||||
_auto_off = millis() + _node_prefs->ui_auto_off_delay * 1000;
|
||||
}
|
||||
#endif
|
||||
if (millis() > _auto_off) {
|
||||
_display->turnOff();
|
||||
if (millis() > _auto_off) {
|
||||
if (_node_prefs->ui_auto_off_blank &&
|
||||
!(_node_prefs->ui_auto_off_keep_msgs
|
||||
&& curr == msg_preview)) {
|
||||
// don't blank if messages are waiting
|
||||
_display->turnOff(true);
|
||||
} else {
|
||||
_display->turnOff();
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef PIN_VIBRATION
|
||||
@@ -1077,10 +1129,13 @@ void UITask::loop() {
|
||||
char UITask::checkDisplayOn(char c) {
|
||||
if (_display != NULL) {
|
||||
if (!_display->isOn()) {
|
||||
_display->turnOn(); // turn display on and consume event
|
||||
_display->turnOn(_node_prefs->ui_max_partial); // turn display on and consume event
|
||||
c = 0;
|
||||
}
|
||||
_auto_off = millis() + AUTO_OFF_MILLIS; // extend auto-off timer
|
||||
_auto_off = millis() + _node_prefs->ui_auto_off_delay * 1000; // extend auto-off timer
|
||||
if (_node_prefs->ui_backlight_on_keys) {
|
||||
_backlight_off = millis() + _node_prefs->ui_backlight_delay * 1000;
|
||||
}
|
||||
_next_refresh = 0; // trigger refresh
|
||||
}
|
||||
return c;
|
||||
|
||||
@@ -61,7 +61,8 @@ class UITask : public AbstractUITask {
|
||||
unsigned long _alert_expiry;
|
||||
int _msgcount;
|
||||
unsigned long ui_started_at, next_batt_chck;
|
||||
int next_backlight_btn_check = 0;
|
||||
unsigned long next_backlight_btn_check = 0;
|
||||
unsigned long _backlight_off = 0;
|
||||
#ifdef PIN_STATUS_LED
|
||||
int led_state = 0;
|
||||
int next_led_change = 0;
|
||||
|
||||
@@ -485,6 +485,7 @@ void UITask::loop() {
|
||||
userLedHandler();
|
||||
|
||||
#ifdef PIN_BUZZER
|
||||
if (buzzer.isQuiet() != (bool)_node_prefs->buzzer_quiet) buzzer.quiet(_node_prefs->buzzer_quiet);
|
||||
if (buzzer.isPlaying()) buzzer.loop();
|
||||
#endif
|
||||
|
||||
|
||||
@@ -691,6 +691,7 @@ void UITask::loop() {
|
||||
userLedHandler();
|
||||
|
||||
#ifdef PIN_BUZZER
|
||||
if (buzzer.isQuiet() != (bool)_node_prefs->buzzer_quiet) buzzer.quiet(_node_prefs->buzzer_quiet);
|
||||
if (buzzer.isPlaying()) buzzer.loop();
|
||||
#endif
|
||||
|
||||
|
||||
@@ -229,8 +229,8 @@ int MyMesh::handleRequest(ClientInfo *sender, uint32_t sender_timestamp, uint8_t
|
||||
stats.n_recv_direct = getNumRecvDirect();
|
||||
stats.err_events = _err_flags;
|
||||
stats.last_snr = (int16_t)(radio_driver.getLastSNR() * 4);
|
||||
stats.n_direct_dups = ((SimpleMeshTables *)getTables())->getNumDirectDups();
|
||||
stats.n_flood_dups = ((SimpleMeshTables *)getTables())->getNumFloodDups();
|
||||
stats.n_direct_dups = std::min<uint32_t>(((SimpleMeshTables *)getTables())->getNumDirectDups(), 0xFFFF);
|
||||
stats.n_flood_dups = std::min<uint32_t>(((SimpleMeshTables *)getTables())->getNumFloodDups(), 0xFFFF);
|
||||
stats.total_rx_air_time_secs = getReceiveAirTime() / 1000;
|
||||
stats.n_recv_errors = radio_driver.getPacketsRecvErrors();
|
||||
memcpy(&reply_data[4], &stats, sizeof(stats));
|
||||
@@ -790,6 +790,7 @@ void MyMesh::onControlDataRecv(mesh::Packet* packet) {
|
||||
uint8_t type = packet->payload[0] & 0xF0; // just test upper 4 bits
|
||||
if (type == CTL_TYPE_NODE_DISCOVER_REQ && packet->payload_len >= 6
|
||||
&& !_prefs.disable_fwd && discover_limiter.allow(rtc_clock.getCurrentTime())
|
||||
&& !isHiddenNode() // this node wishes to NOT be discoverable
|
||||
) {
|
||||
int i = 1;
|
||||
uint8_t filter = packet->payload[i++];
|
||||
|
||||
@@ -67,11 +67,11 @@ struct NeighbourInfo {
|
||||
};
|
||||
|
||||
#ifndef FIRMWARE_BUILD_DATE
|
||||
#define FIRMWARE_BUILD_DATE "14 Aug 2026"
|
||||
#define FIRMWARE_BUILD_DATE "15 Oct 2026"
|
||||
#endif
|
||||
|
||||
#ifndef FIRMWARE_VERSION
|
||||
#define FIRMWARE_VERSION "v1.17.1"
|
||||
#define FIRMWARE_VERSION "v1.18.0"
|
||||
#endif
|
||||
|
||||
#define FIRMWARE_ROLE "repeater"
|
||||
@@ -187,6 +187,9 @@ public:
|
||||
NodePrefs* getNodePrefs() {
|
||||
return &_prefs;
|
||||
}
|
||||
bool isHiddenNode() const {
|
||||
return _prefs.advert_interval == 0 && _prefs.flood_advert_interval == 0;
|
||||
}
|
||||
|
||||
void savePrefs() override {
|
||||
_cli.savePrefs(_fs);
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
#include "MyMesh.h"
|
||||
#include <algorithm>
|
||||
|
||||
#define REPLY_DELAY_MILLIS 1500
|
||||
#define PUSH_NOTIFY_DELAY_MILLIS 2000
|
||||
@@ -170,8 +171,8 @@ int MyMesh::handleRequest(ClientInfo *sender, uint32_t sender_timestamp, uint8_t
|
||||
stats.n_recv_direct = getNumRecvDirect();
|
||||
stats.err_events = _err_flags;
|
||||
stats.last_snr = (int16_t)(radio_driver.getLastSNR() * 4);
|
||||
stats.n_direct_dups = ((SimpleMeshTables *)getTables())->getNumDirectDups();
|
||||
stats.n_flood_dups = ((SimpleMeshTables *)getTables())->getNumFloodDups();
|
||||
stats.n_direct_dups = std::min<uint32_t>(((SimpleMeshTables *)getTables())->getNumDirectDups(), 0xFFFF);
|
||||
stats.n_flood_dups = std::min<uint32_t>(((SimpleMeshTables *)getTables())->getNumFloodDups(), 0xFFFF);
|
||||
stats.n_posted = _num_posted;
|
||||
stats.n_post_push = _num_post_pushes;
|
||||
|
||||
@@ -983,6 +984,8 @@ void MyMesh::handleCommand(uint32_t sender_timestamp, char *command, char *reply
|
||||
addSystemPost(msg);
|
||||
snprintf(reply, MAX_POST_TEXT_LEN, "OK");
|
||||
}
|
||||
} else if (memcmp(command, "set repeat on", 13) == 0) {
|
||||
strcpy(reply, "ERR - repeat now deprecated");
|
||||
} else{
|
||||
_cli.handleCommand(sender_timestamp, command, reply); // common CLI commands
|
||||
}
|
||||
|
||||
@@ -28,11 +28,11 @@
|
||||
/* ------------------------------ Config -------------------------------- */
|
||||
|
||||
#ifndef FIRMWARE_BUILD_DATE
|
||||
#define FIRMWARE_BUILD_DATE "14 Aug 2026"
|
||||
#define FIRMWARE_BUILD_DATE "15 Oct 2026"
|
||||
#endif
|
||||
|
||||
#ifndef FIRMWARE_VERSION
|
||||
#define FIRMWARE_VERSION "v1.17.1"
|
||||
#define FIRMWARE_VERSION "v1.18.0"
|
||||
#endif
|
||||
|
||||
#ifndef LORA_FREQ
|
||||
|
||||
@@ -34,16 +34,16 @@
|
||||
#define PERM_RECV_ALERTS_HI (1 << 7) // high priority alerts
|
||||
|
||||
#ifndef FIRMWARE_BUILD_DATE
|
||||
#define FIRMWARE_BUILD_DATE "14 Aug 2026"
|
||||
#define FIRMWARE_BUILD_DATE "15 Oct 2026"
|
||||
#endif
|
||||
|
||||
#ifndef FIRMWARE_VERSION
|
||||
#define FIRMWARE_VERSION "v1.17.1"
|
||||
#define FIRMWARE_VERSION "v1.18.0"
|
||||
#endif
|
||||
|
||||
#define FIRMWARE_ROLE "sensor"
|
||||
|
||||
#define MAX_SEARCH_RESULTS 8
|
||||
#define MAX_SEARCH_RESULTS 24
|
||||
#define MAX_CONCURRENT_ALERTS 4
|
||||
|
||||
class SensorMesh : public mesh::Mesh, public CommonCLICallbacks {
|
||||
|
||||
+1
-2
@@ -19,8 +19,7 @@ monitor_speed = 115200
|
||||
lib_deps =
|
||||
SPI
|
||||
Wire
|
||||
;jgromes/RadioLib @ ^7.7.1
|
||||
https://github.com/jgromes/RadioLib.git#6d8934836678d8894e3d556550475b37dce3e2b6
|
||||
jgromes/RadioLib @ 7.8.1
|
||||
rweather/Crypto @ ^0.4.0
|
||||
adafruit/RTClib @ ^2.1.3
|
||||
melopero/Melopero RV3028 @ ^1.1.0
|
||||
|
||||
+6
-6
@@ -87,13 +87,14 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
|
||||
}
|
||||
|
||||
if (self_id.isHashMatch(pkt->path, pkt->getPathHashSize()) && allowPacketForward(pkt)) {
|
||||
uint32_t d = getDirectRetransmitDelay(pkt);
|
||||
if (pkt->getPayloadType() == PAYLOAD_TYPE_MULTIPART) {
|
||||
return forwardMultipartDirect(pkt);
|
||||
return forwardMultipartDirect(pkt, d);
|
||||
} else if (pkt->getPayloadType() == PAYLOAD_TYPE_ACK) {
|
||||
if (!_tables->wasSeen(pkt)) { // don't retransmit!
|
||||
_tables->markSeen(pkt);
|
||||
removeSelfFromPath(pkt);
|
||||
routeDirectRecvAcks(pkt, 0);
|
||||
routeDirectRecvAcks(pkt, d);
|
||||
}
|
||||
return ACTION_RELEASE;
|
||||
}
|
||||
@@ -102,7 +103,6 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
|
||||
_tables->markSeen(pkt);
|
||||
removeSelfFromPath(pkt);
|
||||
|
||||
uint32_t d = getDirectRetransmitDelay(pkt);
|
||||
return ACTION_RETRANSMIT_DELAYED(0, d); // Routed traffic is HIGHEST priority
|
||||
}
|
||||
}
|
||||
@@ -356,7 +356,7 @@ DispatcherAction Mesh::routeRecvPacket(Packet* packet) {
|
||||
return ACTION_RELEASE;
|
||||
}
|
||||
|
||||
DispatcherAction Mesh::forwardMultipartDirect(Packet* pkt) {
|
||||
DispatcherAction Mesh::forwardMultipartDirect(Packet* pkt, uint32_t delay_millis) {
|
||||
uint8_t remaining = pkt->payload[0] >> 4; // num of packets in this multipart sequence still to be sent
|
||||
uint8_t type = pkt->payload[0] & 0x0F;
|
||||
|
||||
@@ -370,7 +370,7 @@ DispatcherAction Mesh::forwardMultipartDirect(Packet* pkt) {
|
||||
if (!_tables->wasSeen(&tmp)) { // don't retransmit!
|
||||
_tables->markSeen(&tmp);
|
||||
removeSelfFromPath(&tmp);
|
||||
routeDirectRecvAcks(&tmp, ((uint32_t)remaining + 1) * 300); // expect multipart ACKs 300ms apart (x2)
|
||||
routeDirectRecvAcks(&tmp, delay_millis + ((uint32_t)remaining + 1) * 300); // expect multipart ACKs 300ms apart (x2)
|
||||
}
|
||||
}
|
||||
return ACTION_RELEASE;
|
||||
@@ -380,13 +380,13 @@ void Mesh::routeDirectRecvAcks(Packet* packet, uint32_t delay_millis) {
|
||||
if (!packet->isMarkedDoNotRetransmit()) {
|
||||
uint8_t extra = getExtraAckTransmitCount();
|
||||
while (extra > 0) {
|
||||
delay_millis += getDirectRetransmitDelay(packet) + 300;
|
||||
auto a1 = createMultiAck(packet->payload, packet->payload_len, extra);
|
||||
if (a1) {
|
||||
a1->path_len = Packet::copyPath(a1->path, packet->path, packet->path_len);
|
||||
a1->header &= ~PH_ROUTE_MASK;
|
||||
a1->header |= ROUTE_TYPE_DIRECT;
|
||||
sendPacket(a1, 0, delay_millis);
|
||||
delay_millis += 300;
|
||||
}
|
||||
extra--;
|
||||
}
|
||||
|
||||
+1
-1
@@ -32,7 +32,7 @@ class Mesh : public Dispatcher {
|
||||
void removeSelfFromPath(Packet* packet);
|
||||
void routeDirectRecvAcks(Packet* packet, uint32_t delay_millis);
|
||||
//void routeRecvAcks(Packet* packet, uint32_t delay_millis);
|
||||
DispatcherAction forwardMultipartDirect(Packet* pkt);
|
||||
DispatcherAction forwardMultipartDirect(Packet* pkt, uint32_t delay_millis);
|
||||
|
||||
protected:
|
||||
DispatcherAction onRecvPacket(Packet* pkt) override;
|
||||
|
||||
@@ -68,6 +68,16 @@ public:
|
||||
// Power management interface (boards with power management override these)
|
||||
virtual bool isPwrMgtInitialised() const { return false; }
|
||||
virtual bool isExternalPowered() { return false; }
|
||||
// True while a board can identify an active battery-charging source.
|
||||
virtual bool isChargerActive() { return false; }
|
||||
|
||||
// Optional, source-specific power detection. Boards that can distinguish a USB
|
||||
// supply from a solar charger override these; defaults keep every other board
|
||||
// unaffected (the generic CLI prints "n/a" when a capability is absent).
|
||||
virtual bool hasUsbPowerDetect() const { return false; }
|
||||
virtual bool isUsbPowered() { return false; }
|
||||
virtual bool hasSolarChargerDetect() const { return false; }
|
||||
virtual bool isSolarChargerActive() { return false; }
|
||||
virtual uint16_t getBootVoltage() { return 0; }
|
||||
virtual bool getWakeLpcompSupported() const { return false; }
|
||||
virtual uint32_t getResetReason() const { return 0; }
|
||||
|
||||
+5
-2
@@ -147,6 +147,9 @@ int Utils::encryptThenMAC(const uint8_t* shared_secret, uint8_t* dest, const uin
|
||||
int Utils::MACThenDecrypt(const uint8_t* shared_secret, uint8_t* dest, const uint8_t* src, int src_len) {
|
||||
if (src_len <= CIPHER_MAC_SIZE) return 0; // invalid src bytes
|
||||
|
||||
int enc_len = src_len - CIPHER_MAC_SIZE;
|
||||
if (enc_len % CIPHER_BLOCK_SIZE != 0) return 0; // reject non-block-aligned ciphertext
|
||||
|
||||
uint8_t hmac[CIPHER_MAC_SIZE];
|
||||
#ifdef USE_CC310_HW_CRYPTO
|
||||
{
|
||||
@@ -161,12 +164,12 @@ int Utils::MACThenDecrypt(const uint8_t* shared_secret, uint8_t* dest, const uin
|
||||
{
|
||||
SHA256 sha;
|
||||
sha.resetHMAC(shared_secret, PUB_KEY_SIZE);
|
||||
sha.update(src + CIPHER_MAC_SIZE, src_len - CIPHER_MAC_SIZE);
|
||||
sha.update(src + CIPHER_MAC_SIZE, enc_len);
|
||||
sha.finalizeHMAC(shared_secret, PUB_KEY_SIZE, hmac, CIPHER_MAC_SIZE);
|
||||
}
|
||||
#endif
|
||||
if (memcmp(hmac, src, CIPHER_MAC_SIZE) == 0) {
|
||||
return decrypt(shared_secret, dest, src + CIPHER_MAC_SIZE, src_len - CIPHER_MAC_SIZE);
|
||||
return decrypt(shared_secret, dest, src + CIPHER_MAC_SIZE, enc_len);
|
||||
}
|
||||
return 0; // invalid HMAC
|
||||
}
|
||||
|
||||
+1
-1
@@ -50,7 +50,7 @@ public:
|
||||
|
||||
/**
|
||||
* \brief checks the MAC (in leading bytes of 'src'), then if valid, decrypts remaining bytes in src.
|
||||
* \returns zero if MAC is invalid, otherwise the length of decrypted bytes in 'dest'
|
||||
* \returns zero if MAC is invalid or ciphertext is not block-aligned, otherwise the length of decrypted bytes in 'dest'
|
||||
*/
|
||||
static int MACThenDecrypt(const uint8_t* shared_secret, uint8_t* dest, const uint8_t* src, int src_len);
|
||||
|
||||
|
||||
@@ -128,6 +128,7 @@ void BaseChatMesh::onAdvertRecv(mesh::Packet* packet, const mesh::Identity& id,
|
||||
|
||||
ContactInfo* from = NULL;
|
||||
for (int i = 0; i < num_contacts; i++) {
|
||||
if (contacts[i].isEmptySlot()) continue;
|
||||
if (id.matches(contacts[i].id)) { // is from one of our contacts
|
||||
from = &contacts[i];
|
||||
if (timestamp <= from->last_advert_timestamp) { // check for replay attacks!!
|
||||
@@ -203,6 +204,11 @@ void BaseChatMesh::onAdvertRecv(mesh::Packet* packet, const mesh::Identity& id,
|
||||
int BaseChatMesh::searchPeersByHash(const uint8_t* hash) {
|
||||
int n = 0;
|
||||
for (int i = 0; i < num_contacts && n < MAX_SEARCH_RESULTS; i++) {
|
||||
// Skip empty/unconfigured anon slots. An empty slot has an all-zero pub_key
|
||||
// (an order-4 Edwards25519 point whose clamped X25519 key exchange yields an
|
||||
// all-zero shared secret for any private key) and would otherwise match
|
||||
// src_hash == 0x00 as a null-key peer sink while consuming search slots.
|
||||
if (contacts[i].isEmptySlot()) continue;
|
||||
if (contacts[i].id.isHashMatch(hash)) {
|
||||
matching_peer_indexes[n++] = i; // store the INDEXES of matching contacts (for subsequent 'peer' methods)
|
||||
}
|
||||
@@ -516,6 +522,11 @@ int BaseChatMesh::sendCommandData(const ContactInfo& recipient, uint32_t timest
|
||||
}
|
||||
|
||||
bool BaseChatMesh::sendGroupMessage(uint32_t timestamp, mesh::GroupChannel& channel, const char* sender_name, const char* text, int text_len) {
|
||||
if (text_len < 0) { // memcpy() below would read this as a size_t, so clamping cannot catch it
|
||||
MESH_DEBUG_PRINTLN("sendGroupMessage: invalid negative text_len=%d", text_len);
|
||||
return false;
|
||||
}
|
||||
|
||||
uint8_t temp[5+MAX_TEXT_LEN+32];
|
||||
memcpy(temp, ×tamp, 4); // mostly an extra blob to help make packet_hash unique
|
||||
temp[4] = 0; // TXT_TYPE_PLAIN
|
||||
@@ -866,6 +877,7 @@ ContactInfo* BaseChatMesh::searchContactsByPrefix(const char* name_prefix) {
|
||||
int len = strlen(name_prefix);
|
||||
for (int i = 0; i < num_contacts; i++) {
|
||||
auto c = &contacts[i];
|
||||
if (c->isEmptySlot() || c->name[0] == 0) continue;
|
||||
if (memcmp(c->name, name_prefix, len) == 0) return c;
|
||||
}
|
||||
return NULL; // not found
|
||||
@@ -874,6 +886,7 @@ ContactInfo* BaseChatMesh::searchContactsByPrefix(const char* name_prefix) {
|
||||
ContactInfo* BaseChatMesh::lookupContactByPubKey(const uint8_t* pub_key, int prefix_len) {
|
||||
for (int i = 0; i < num_contacts; i++) {
|
||||
auto c = &contacts[i];
|
||||
if (c->isEmptySlot()) continue;
|
||||
if (memcmp(c->id.pub_key, pub_key, prefix_len) == 0) return c;
|
||||
}
|
||||
return NULL; // not found
|
||||
@@ -891,7 +904,7 @@ bool BaseChatMesh::addContact(const ContactInfo& contact) {
|
||||
|
||||
bool BaseChatMesh::removeContact(ContactInfo& contact) {
|
||||
int idx = 0;
|
||||
while (idx < num_contacts && !contacts[idx].id.matches(contact.id)) {
|
||||
while (idx < num_contacts && (contacts[idx].isEmptySlot() || !contacts[idx].id.matches(contact.id))) {
|
||||
idx++;
|
||||
}
|
||||
if (idx >= num_contacts) return false; // not found
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
|
||||
#include "ContactInfo.h"
|
||||
|
||||
#define MAX_SEARCH_RESULTS 8
|
||||
#define MAX_SEARCH_RESULTS 24
|
||||
|
||||
#define MSG_SEND_FAILED 0
|
||||
#define MSG_SEND_SENT_FLOOD 1
|
||||
|
||||
@@ -284,6 +284,19 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* re
|
||||
sprintf(reply, "%s (Build: %s)", _callbacks->getFirmwareVer(), _callbacks->getBuildDate());
|
||||
} else if (memcmp(command, "board", 5) == 0) {
|
||||
sprintf(reply, "%s", _board->getManufacturerName());
|
||||
} else if (strcmp(command, "power") == 0) {
|
||||
const char* usb_state = _board->hasUsbPowerDetect()
|
||||
? (_board->isUsbPowered() ? "yes" : "no")
|
||||
: "n/a";
|
||||
const char* solar_state = _board->hasSolarChargerDetect()
|
||||
? (_board->isSolarChargerActive() ? "yes" : "no")
|
||||
: "n/a";
|
||||
snprintf(reply, 160, "batt:%u mV usb:%s solar_chg:%s ext:%s charger:%s",
|
||||
(unsigned)_board->getBattMilliVolts(),
|
||||
usb_state,
|
||||
solar_state,
|
||||
_board->isExternalPowered() ? "yes" : "no",
|
||||
_board->isChargerActive() ? "yes" : "no");
|
||||
} else if (memcmp(command, "sensor get ", 11) == 0) {
|
||||
const char* key = command + 11;
|
||||
const char* val = _sensors->getSettingByKey(key);
|
||||
@@ -313,18 +326,26 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* re
|
||||
if (start >= end) {
|
||||
strcpy(reply, "no custom var");
|
||||
} else {
|
||||
const int reply_max = 160; // callers pass a 160-byte reply buffer
|
||||
const int next_reserve = 16; // room for "... next:NNN"
|
||||
sprintf(dp, "%d vars\n", end);
|
||||
dp = strchr(dp, 0);
|
||||
int i;
|
||||
for (i = start; i < end && (dp-reply < 134); i++) {
|
||||
sprintf(dp, "%s=%s\n",
|
||||
_sensors->getSettingName(i),
|
||||
_sensors->getSettingValue(i));
|
||||
for (i = start; i < end; i++) {
|
||||
const char* name = _sensors->getSettingName(i);
|
||||
const char* value = _sensors->getSettingValue(i);
|
||||
if (name == NULL) name = "?";
|
||||
if (value == NULL) value = "";
|
||||
int room = reply_max - next_reserve - (int)(dp - reply);
|
||||
int need = snprintf(NULL, 0, "%s=%s\n", name, value);
|
||||
if (need >= room && i > start) break; // continue on the next page
|
||||
snprintf(dp, room, "%s=%s\n", name, value); // a single oversized entry is truncated
|
||||
dp = strchr(dp, 0);
|
||||
if (need >= room) { i++; break; }
|
||||
}
|
||||
if (i < end) {
|
||||
sprintf(dp, "... next:%d", i);
|
||||
} else {
|
||||
snprintf(dp, reply_max - (int)(dp - reply), "... next:%d", i);
|
||||
} else if (dp > reply && *(dp-1) == '\n') {
|
||||
*(dp-1) = 0; // remove last CR
|
||||
}
|
||||
}
|
||||
@@ -355,6 +376,20 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* re
|
||||
} else {
|
||||
strcpy(reply, "gps provider not found");
|
||||
}
|
||||
} else if (strcmp(command, "gps diag") == 0) {
|
||||
LocationProvider * l = _sensors->getLocationProvider();
|
||||
if (l != NULL) {
|
||||
const char* setting = _sensors->getSettingByKey("gps");
|
||||
bool requested = setting != NULL && strcmp(setting, "1") == 0;
|
||||
int prefix_len = snprintf(reply, 160, "req:%u ", requested ? 1U : 0U);
|
||||
if (prefix_len < 0 || prefix_len >= 160) {
|
||||
reply[159] = 0;
|
||||
} else {
|
||||
l->formatDiagnostics(reply + prefix_len, 160 - prefix_len);
|
||||
}
|
||||
} else {
|
||||
strcpy(reply, "gps provider not found");
|
||||
}
|
||||
} else if (memcmp(command, "gps setloc", 10) == 0) {
|
||||
_prefs->node_lat = _sensors->node_lat;
|
||||
_prefs->node_lon = _sensors->node_lon;
|
||||
|
||||
@@ -115,8 +115,8 @@ private:
|
||||
void setIntThresh(uint8_t t) override { _parent->interference_threshold = t; markDirty(); }
|
||||
uint8_t getRxGain() const override { return _parent->rx_boosted_gain; }
|
||||
void setRxGain(uint8_t g) override { _parent->rx_boosted_gain = g; markDirty(); }
|
||||
uint8_t getTxPower() const override { return _parent->tx_power_dbm; }
|
||||
void setTxPower(uint8_t dbm) override { _parent->tx_power_dbm = dbm; markDirty(); }
|
||||
int8_t getTxPower() const override { return _parent->tx_power_dbm; }
|
||||
void setTxPower(int8_t dbm) override { _parent->tx_power_dbm = dbm; markDirty(); }
|
||||
float getRxDelay() const override { return _parent->rx_delay_base; }
|
||||
void setRxDelay(float d) override { _parent->rx_delay_base = d; markDirty(); }
|
||||
uint16_t getAgcResetInt() const override { return _parent->agc_reset_interval * 4; }
|
||||
|
||||
@@ -2,6 +2,22 @@
|
||||
#include "TxtDataHelpers.h"
|
||||
#include "Utils.h"
|
||||
#include "target.h"
|
||||
#include <ctype.h>
|
||||
|
||||
namespace {
|
||||
|
||||
// strtof() and atof() also read "nan" and "inf". A NaN cannot be refused by a
|
||||
// range check: no ordered comparison is true for it, and under -ffast-math,
|
||||
// which nRF52 builds use, the compiler may assume it never occurs and fold any
|
||||
// test on the parsed value away. So the text is checked before it is parsed:
|
||||
// after optional white space and sign, a number starts with a digit or a '.'.
|
||||
bool looksLikeANumber(const char* s) {
|
||||
while (isspace((unsigned char)*s)) s++;
|
||||
if (*s == '+' || *s == '-') s++;
|
||||
return isdigit((unsigned char)*s) || *s == '.';
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
bool CommonRadioPrefs::getByKey(const char* key, char* value, size_t max_len) {
|
||||
if (strcmp(key, "fem_rxgain") == 0) {
|
||||
@@ -69,7 +85,7 @@ bool CommonRadioPrefs::handleCommand(const char* command, uint32_t sender_timest
|
||||
if (memcmp(command, "set af ", 7) == 0) {
|
||||
char* end;
|
||||
float af = strtof(&command[7], &end);
|
||||
if (end == &command[7] || af < 0 || af > 9) {
|
||||
if (end == &command[7] || !looksLikeANumber(&command[7]) || af < 0 || af > 9) {
|
||||
strcpy(reply, "ERROR: af must be 0-9");
|
||||
} else {
|
||||
setAirtimeFactor(af);
|
||||
@@ -87,7 +103,7 @@ bool CommonRadioPrefs::handleCommand(const char* command, uint32_t sender_timest
|
||||
}
|
||||
if (memcmp(command, "set dutycycle ", 14) == 0) {
|
||||
float dc = atof(&command[14]);
|
||||
if (dc < 1 || dc > 100) {
|
||||
if (!looksLikeANumber(&command[14]) || dc < 1 || dc > 100) {
|
||||
strcpy(reply, "ERROR: dutycycle must be 1-100");
|
||||
} else {
|
||||
setAirtimeFactor((100.0f / dc) - 1.0f);
|
||||
|
||||
@@ -35,8 +35,8 @@ public:
|
||||
virtual uint8_t getRxGain() const = 0;
|
||||
virtual void setRxGain(uint8_t g) = 0;
|
||||
|
||||
virtual uint8_t getTxPower() const = 0;
|
||||
virtual void setTxPower(uint8_t dbm) = 0;
|
||||
virtual int8_t getTxPower() const = 0;
|
||||
virtual void setTxPower(int8_t dbm) = 0;
|
||||
|
||||
virtual float getRxDelay() const = 0;
|
||||
virtual void setRxDelay(float d) = 0;
|
||||
|
||||
@@ -31,6 +31,12 @@ struct ContactInfo {
|
||||
bool isTelemLocAllowed() const { return flags & 0x04; }
|
||||
bool isTelemEnvAllowed() const { return flags & 0x08; }
|
||||
bool isRemoteCLIAllowed() const { return flags & 0x10; }
|
||||
bool isEmptySlot() const {
|
||||
for (int i = 0; i < PUB_KEY_SIZE; i++) {
|
||||
if (id.pub_key[i] != 0) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
private:
|
||||
mutable uint8_t shared_secret[PUB_KEY_SIZE];
|
||||
|
||||
@@ -3,6 +3,10 @@
|
||||
#include "ESP32Board.h"
|
||||
#include <target.h>
|
||||
|
||||
// The RTC backup of ESP32RTCClock, declared in ESP32Board.h.
|
||||
RTC_NOINIT_ATTR uint32_t _rtc_backup_time;
|
||||
RTC_NOINIT_ATTR uint32_t _rtc_backup_magic;
|
||||
|
||||
#if defined(ADMIN_PASSWORD) && !defined(DISABLE_WIFI_OTA) // Repeater or Room Server only
|
||||
#include <WiFi.h>
|
||||
#include <AsyncTCP.h>
|
||||
|
||||
@@ -200,19 +200,33 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
// The time ESP32RTCClock restores after a reset, in RTC memory that a reset does
|
||||
// not clear. Defined once, in ESP32Board.cpp: the inline members below run in
|
||||
// every translation unit that uses them and must all see the same backup.
|
||||
extern uint32_t _rtc_backup_time;
|
||||
extern uint32_t _rtc_backup_magic;
|
||||
#define RTC_BACKUP_MAGIC 0xAA55CC33
|
||||
#define RTC_TIME_MIN 1772323200 // 1 Mar 2026
|
||||
|
||||
class ESP32RTCClock : public mesh::RTCClock {
|
||||
public:
|
||||
ESP32RTCClock() { }
|
||||
void begin() {
|
||||
esp_reset_reason_t reason = esp_reset_reason();
|
||||
if (reason == ESP_RST_POWERON) {
|
||||
// start with some date/time in the recent past
|
||||
struct timeval tv;
|
||||
tv.tv_sec = 1715770351; // 15 May 2024, 8:50pm
|
||||
if (reason == ESP_RST_DEEPSLEEP) {
|
||||
return; // ESP-IDF preserves system time across deep sleep
|
||||
}
|
||||
// All other resets (power-on, crash, WDT, brownout) lose system time.
|
||||
// Restore from RTC backup if valid, otherwise use hardcoded seed.
|
||||
struct timeval tv;
|
||||
if (_rtc_backup_magic == RTC_BACKUP_MAGIC && _rtc_backup_time > RTC_TIME_MIN) {
|
||||
tv.tv_sec = _rtc_backup_time;
|
||||
} else {
|
||||
tv.tv_sec = RTC_TIME_MIN;
|
||||
}
|
||||
tv.tv_usec = 0;
|
||||
settimeofday(&tv, NULL);
|
||||
}
|
||||
}
|
||||
uint32_t getCurrentTime() override {
|
||||
time_t _now;
|
||||
time(&_now);
|
||||
@@ -223,6 +237,16 @@ public:
|
||||
tv.tv_sec = time;
|
||||
tv.tv_usec = 0;
|
||||
settimeofday(&tv, NULL);
|
||||
_rtc_backup_time = time;
|
||||
_rtc_backup_magic = RTC_BACKUP_MAGIC;
|
||||
}
|
||||
void tick() override {
|
||||
time_t now;
|
||||
time(&now);
|
||||
if (now > RTC_TIME_MIN && (uint32_t)now != _rtc_backup_time) {
|
||||
_rtc_backup_time = (uint32_t)now;
|
||||
_rtc_backup_magic = RTC_BACKUP_MAGIC;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -188,6 +188,7 @@ int RegionMap::getTransportKeysFor(const RegionEntry& src, TransportKey dest[],
|
||||
}
|
||||
|
||||
RegionEntry* RegionMap::findMatch(mesh::Packet* packet, uint8_t mask) {
|
||||
if (packet->transport_codes[0] == 0) return (wildcard.flags & mask) == 0 ? &wildcard : NULL;
|
||||
for (int i = 0; i < num_regions; i++) {
|
||||
auto region = ®ions[i];
|
||||
if ((region->flags & mask) == 0) { // does region allow this? (per 'mask' param)
|
||||
|
||||
@@ -17,6 +17,7 @@ inline bool isFloodHopLimitExceeded(const Packet* packet, uint8_t flood_max,
|
||||
uint8_t hops = packet->getPathHashCount();
|
||||
if (hops >= flood_max) return true;
|
||||
if (packet->getRouteType() == ROUTE_TYPE_FLOOD && hops >= flood_max_unscoped) return true;
|
||||
if (packet->getRouteType() == ROUTE_TYPE_TRANSPORT_FLOOD && packet->transport_codes[0] == 0 && hops >= flood_max_unscoped) return true; // scope 0, treat as unscoped
|
||||
if (packet->getPayloadType() == PAYLOAD_TYPE_ADVERT && hops >= flood_max_advert) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -129,8 +129,12 @@ void SerialBLEInterface::begin(const char* prefix, char* name, uint32_t pin_code
|
||||
char charpin[20];
|
||||
snprintf(charpin, sizeof(charpin), "%lu", (unsigned long)pin_code);
|
||||
|
||||
// If we want to control BLE LED ourselves, uncomment this:
|
||||
// Bluefruit.autoConnLed(false);
|
||||
#ifdef DISABLE_BLE_LED // use variant platformio.ini build_flags macro: -D DISABLE_BLE_LED
|
||||
Bluefruit.autoConnLed(false); // false removes the automatic control of the LED by the Bluefruit library
|
||||
#else
|
||||
Bluefruit.autoConnLed(true); // true leaves the default automatic control of the LED by the Bluefruit library
|
||||
#endif
|
||||
|
||||
Bluefruit.configPrphBandwidth(BANDWIDTH_MAX);
|
||||
Bluefruit.begin();
|
||||
|
||||
|
||||
@@ -20,6 +20,11 @@ public:
|
||||
|
||||
}
|
||||
|
||||
bool lastRxHadCRC() override {
|
||||
bool crc = true;
|
||||
((CustomLLCC68 *)_radio)->getLoRaRxHeaderInfo(NULL, &crc);
|
||||
return crc;
|
||||
}
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomLLCC68 *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -19,6 +19,11 @@ public:
|
||||
((CustomLR1110 *)_radio)->setMaxPayloadMillis(pm.payloadMillis);
|
||||
}
|
||||
|
||||
bool lastRxHadCRC() override {
|
||||
bool crc = true;
|
||||
((CustomLR1110 *)_radio)->getLoRaRxHeaderInfo(NULL, &crc);
|
||||
return crc;
|
||||
}
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomLR1110 *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -9,6 +9,8 @@ class CustomLR1121 : public LR1121 {
|
||||
uint32_t _activityAt = 0;
|
||||
bool _headerSeen = false;
|
||||
bool _rx_boosted = false;
|
||||
int8_t _txPower = 0;
|
||||
bool _txPowerSet = false;
|
||||
|
||||
public:
|
||||
CustomLR1121(Module *mod) : LR1121(mod) { }
|
||||
@@ -36,6 +38,33 @@ class CustomLR1121 : public LR1121 {
|
||||
return len;
|
||||
}
|
||||
|
||||
using LR1121::setOutputPower;
|
||||
using LR1121::setFrequency;
|
||||
|
||||
int16_t setOutputPower(int8_t power) override {
|
||||
#ifdef LR1121_FORCE_HP_PA
|
||||
const bool force_hp = true; // boards with only RFO_HP_LF wired: never select the LP PA
|
||||
#else
|
||||
const bool force_hp = false;
|
||||
#endif
|
||||
// clip to the active PA's range (HF PA tops out at 13 dBm) rather than fail and keep the other band's PA
|
||||
int8_t clipped = power;
|
||||
checkOutputPower(power, &clipped, force_hp);
|
||||
int16_t state = LR1121::setOutputPower(clipped, force_hp);
|
||||
if (state == RADIOLIB_ERR_NONE) {
|
||||
_txPower = power;
|
||||
_txPowerSet = true;
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
int16_t setFrequency(float freq) override {
|
||||
int16_t state = LR1121::setFrequency(freq);
|
||||
// PA selection depends on the band, and set radio / tempradio don't call setTxPower
|
||||
if (state == RADIOLIB_ERR_NONE && _txPowerSet) state = setOutputPower(_txPower);
|
||||
return state;
|
||||
}
|
||||
|
||||
float getFreqMHz() const { return freqMHz; }
|
||||
|
||||
int16_t setRxBoostedGainMode(bool en) {
|
||||
|
||||
@@ -20,6 +20,11 @@ public:
|
||||
}
|
||||
|
||||
void doResetAGC() override { lr11x0ResetAGC((LR11x0 *)_radio, ((CustomLR1121 *)_radio)->getFreqMHz(), getRxBoostedGainMode()); }
|
||||
bool lastRxHadCRC() override {
|
||||
bool crc = true;
|
||||
((CustomLR1121 *)_radio)->getLoRaRxHeaderInfo(NULL, &crc);
|
||||
return crc;
|
||||
}
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomLR1121 *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -16,15 +16,23 @@ public:
|
||||
CustomLR2021Wrapper(CustomLR2021& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
|
||||
|
||||
void setParams(float freq, float bw, uint8_t sf, uint8_t cr) override {
|
||||
((CustomLR2021 *)_radio)->setFrequency(freq);
|
||||
((CustomLR2021 *)_radio)->setSpreadingFactor(sf);
|
||||
((CustomLR2021 *)_radio)->setBandwidth(bw);
|
||||
((CustomLR2021 *)_radio)->setCodingRate(cr);
|
||||
auto r = (CustomLR2021 *)_radio;
|
||||
// LR2021 only accepts RF/modulation config commands while in STANDBY mode.
|
||||
// Re-configuring while in continuous RX gets silently rejected (-706),
|
||||
// which broke hot frequency changes over BLE.
|
||||
int16_t status = r->standby();
|
||||
if (status != RADIOLIB_ERR_NONE) { MESH_DEBUG_PRINTLN("CustomLR2021Wrapper: standby() -> %d", status); }
|
||||
if ((status = r->setFrequency(freq)) != RADIOLIB_ERR_NONE) { MESH_DEBUG_PRINTLN("CustomLR2021Wrapper: setFrequency() -> %d", status); }
|
||||
if ((status = r->setSpreadingFactor(sf)) != RADIOLIB_ERR_NONE) { MESH_DEBUG_PRINTLN("CustomLR2021Wrapper: setSpreadingFactor() -> %d", status); }
|
||||
if ((status = r->setBandwidth(bw)) != RADIOLIB_ERR_NONE) { MESH_DEBUG_PRINTLN("CustomLR2021Wrapper: setBandwidth() -> %d", status); }
|
||||
if ((status = r->setCodingRate(cr)) != RADIOLIB_ERR_NONE) { MESH_DEBUG_PRINTLN("CustomLR2021Wrapper: setCodingRate() -> %d", status); }
|
||||
updatePreamble(sf);
|
||||
applySideDetectorConfig();
|
||||
// internal idle() sets STATE_IDLE, which triggers a startReceive() on the next loop
|
||||
status = applySideDetectorConfig();
|
||||
if (status != RADIOLIB_ERR_NONE) { MESH_DEBUG_PRINTLN("CustomLR2021Wrapper: applySideDetectorConfig() -> %d", status); }
|
||||
PacketMillis pm = calcMaxPacketMillis(sf, bw, cr, preambleLengthForSF(sf));
|
||||
((CustomLR2021 *)_radio)->setPreambleMillis(pm.preambleMillis);
|
||||
((CustomLR2021 *)_radio)->setMaxPayloadMillis(pm.payloadMillis);
|
||||
r->setPreambleMillis(pm.preambleMillis); // pure in-memory setters, no standby needed
|
||||
r->setMaxPayloadMillis(pm.payloadMillis);
|
||||
|
||||
}
|
||||
|
||||
@@ -73,6 +81,11 @@ public:
|
||||
return tSym;
|
||||
}
|
||||
|
||||
bool lastRxHadCRC() override {
|
||||
bool crc = true;
|
||||
((CustomLR2021 *)_radio)->getLoRaRxHeaderInfo(NULL, &crc);
|
||||
return crc;
|
||||
}
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomLR2021 *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -20,6 +20,11 @@ public:
|
||||
((CustomSTM32WLx *)_radio)->setMaxPayloadMillis(pm.payloadMillis);
|
||||
}
|
||||
|
||||
bool lastRxHadCRC() override {
|
||||
bool crc = true;
|
||||
((CustomSTM32WLx *)_radio)->getLoRaRxHeaderInfo(NULL, &crc);
|
||||
return crc;
|
||||
}
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomSTM32WLx *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -23,6 +23,11 @@ public:
|
||||
((CustomSX1262 *)_radio)->setMaxPayloadMillis(pm.payloadMillis);
|
||||
}
|
||||
|
||||
bool lastRxHadCRC() override {
|
||||
bool crc = true;
|
||||
((CustomSX1262 *)_radio)->getLoRaRxHeaderInfo(NULL, &crc);
|
||||
return crc;
|
||||
}
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomSX1262 *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -23,6 +23,11 @@ public:
|
||||
((CustomSX1268 *)_radio)->setMaxPayloadMillis(pm.payloadMillis);
|
||||
}
|
||||
|
||||
bool lastRxHadCRC() override {
|
||||
bool crc = true;
|
||||
((CustomSX1268 *)_radio)->getLoRaRxHeaderInfo(NULL, &crc);
|
||||
return crc;
|
||||
}
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomSX1268 *)_radio)->isReceiving();
|
||||
}
|
||||
|
||||
@@ -132,6 +132,9 @@ int RadioLibWrapper::recvRaw(uint8_t* bytes, int sz) {
|
||||
if (len > 0) {
|
||||
if (len > sz) { len = sz; }
|
||||
int err = _radio->readData(bytes, len);
|
||||
if (err == RADIOLIB_ERR_NONE && !lastRxHadCRC()) {
|
||||
err = RADIOLIB_ERR_LORA_HEADER_DAMAGED; // header says no CRC, so the payload was never checked
|
||||
}
|
||||
if (err != RADIOLIB_ERR_NONE) {
|
||||
MESH_DEBUG_PRINTLN("RadioLibWrapper: error: readData(%d)", err);
|
||||
len = 0;
|
||||
|
||||
@@ -26,10 +26,14 @@ protected:
|
||||
void startRecv();
|
||||
float packetScoreInt(float snr, int sf, int packet_len);
|
||||
virtual bool isReceivingPacket() =0;
|
||||
virtual bool lastRxHadCRC() { return true; }
|
||||
virtual void doResetAGC();
|
||||
|
||||
public:
|
||||
RadioLibWrapper(PhysicalLayer& radio, mesh::MainBoard& board) : _radio(&radio), _board(&board), _preamble_sf(0) { n_recv = n_sent = 0; }
|
||||
RadioLibWrapper(PhysicalLayer& radio, mesh::MainBoard& board)
|
||||
: _radio(&radio), _board(&board), _preamble_sf(0) {
|
||||
n_recv = n_sent = n_recv_errors = 0;
|
||||
}
|
||||
|
||||
void begin() override;
|
||||
virtual void powerOff() { _radio->sleep(); }
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
#pragma once
|
||||
#include <helpers/sensors/LocationProvider.h>
|
||||
|
||||
// Board must keep the GPS RTC backup pin powered and can cut GPS power once we return.
|
||||
// Returns true if the command was acked within 3 attempts, otherwise returns false.
|
||||
static inline bool airohaEnterSleep(LocationProvider* nmea) {
|
||||
for (uint8_t attempt = 0; attempt < 3; attempt++) {
|
||||
nmea->drain();
|
||||
nmea->sendSentence("$PAIR650,0");
|
||||
if (nmea->waitFor("$PAIR001,650,0", 50)) { // wait for the command received signal
|
||||
#ifdef GPS_NMEA_DEBUG
|
||||
Serial.printf("Airoha RTC Backup sleep command accepted by GPS after %u attempts\r\n", attempt + 1);
|
||||
#endif
|
||||
nmea->waitFor("$PAIR650,0", 50); // give the GPS 50ms grace to signal it is ready for sleep
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -765,14 +765,18 @@ void EnvironmentSensorManager::initBasicGPS() {
|
||||
MESH_DEBUG_PRINTLN("No GPS wake/reset pin found for this board. Continuing on...");
|
||||
#endif
|
||||
|
||||
// Give GPS a moment to power up and send data
|
||||
delay(1000);
|
||||
|
||||
// We'll consider GPS detected if we see any data on Serial1
|
||||
// Give the GPS time to power up and emit its first NMEA sentence. Cold-start
|
||||
// modules can take several seconds, so poll for up to ~5s instead of checking
|
||||
// once after a fixed 1s delay -- returning as soon as any data appears, so
|
||||
// fast modules add no boot delay (issue #2258).
|
||||
#ifdef ENV_SKIP_GPS_DETECT
|
||||
gps_detected = true;
|
||||
#else
|
||||
gps_detected = (Serial1.available() > 0);
|
||||
gps_detected = false;
|
||||
for (int i = 0; i < 20 && !gps_detected; i++) {
|
||||
delay(250);
|
||||
gps_detected = (Serial1.available() > 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (gps_detected) {
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
#pragma once
|
||||
|
||||
#include "Mesh.h"
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
class LocationProvider {
|
||||
@@ -17,9 +19,21 @@ public:
|
||||
virtual bool isValid() = 0;
|
||||
virtual long getTimestamp() = 0;
|
||||
virtual void sendSentence(const char * sentence);
|
||||
virtual bool waitFor(const char* prefix, uint32_t timeout_ms) { return false; }
|
||||
virtual void drain() { }
|
||||
virtual void reset() = 0;
|
||||
virtual void begin() = 0;
|
||||
virtual void stop() = 0;
|
||||
virtual void loop() = 0;
|
||||
virtual bool isEnabled() = 0;
|
||||
|
||||
// Format compact diagnostics in the caller-provided buffer. Providers that
|
||||
// have more information (for example UART counters) can override this.
|
||||
virtual void formatDiagnostics(char* out, size_t out_size) {
|
||||
if (out_size == 0) return;
|
||||
snprintf(out, out_size, "en:%u sat:%ld fix:%u",
|
||||
isEnabled() ? 1U : 0U,
|
||||
satellitesCount(),
|
||||
isValid() ? 1U : 0U);
|
||||
}
|
||||
};
|
||||
@@ -4,6 +4,7 @@
|
||||
#include <MicroNMEA.h>
|
||||
#include <RTClib.h>
|
||||
#include <helpers/RefCountedDigitalPin.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifndef GPS_EN
|
||||
#ifdef PIN_GPS_EN
|
||||
@@ -51,6 +52,42 @@ class MicroNMEALocationProvider : public LocationProvider {
|
||||
unsigned long _last_time_sync = 0;
|
||||
static const unsigned long TIME_SYNC_INTERVAL = 1800000; // Re-sync every 30 minutes
|
||||
|
||||
#ifdef GPS_L76K
|
||||
void configureL76K() {
|
||||
// Reapply the constellation mode at each provider start instead of
|
||||
// assuming it survives a receiver power cycle.
|
||||
// Mode 7 enables GPS + BeiDou + GLONASS.
|
||||
delay(250);
|
||||
MicroNMEA::sendSentence(*_gps_serial, "$PCAS04,7");
|
||||
delay(250);
|
||||
}
|
||||
#endif
|
||||
// Observation-only diagnostics. These fields do not change GPS power,
|
||||
// timing, reset behaviour, or parser input.
|
||||
uint32_t _uart_bytes = 0;
|
||||
uint32_t _nmea_checksum_ok = 0;
|
||||
uint32_t _nmea_checksum_bad = 0;
|
||||
uint32_t _begin_calls = 0;
|
||||
uint32_t _stop_calls = 0;
|
||||
unsigned long _last_uart_ms = 0;
|
||||
unsigned long _last_nmea_ms = 0;
|
||||
unsigned long _last_fix_ms = 0;
|
||||
bool _uart_seen = false;
|
||||
bool _nmea_seen = false;
|
||||
bool _fix_seen = false;
|
||||
|
||||
static uint32_t ageMs(unsigned long timestamp) {
|
||||
return (uint32_t)(millis() - timestamp);
|
||||
}
|
||||
|
||||
static void formatAge(char* out, size_t out_size, bool seen, unsigned long timestamp) {
|
||||
if (!seen) {
|
||||
snprintf(out, out_size, "never");
|
||||
} else {
|
||||
snprintf(out, out_size, "%lu", (unsigned long)ageMs(timestamp));
|
||||
}
|
||||
}
|
||||
|
||||
public :
|
||||
MicroNMEALocationProvider(Stream& ser, mesh::RTCClock* clock = NULL, int pin_reset = GPS_RESET, int pin_en = GPS_EN,RefCountedDigitalPin* peripher_power=NULL) :
|
||||
nmea(_nmeaBuffer, sizeof(_nmeaBuffer)), _clock(clock), _gps_serial(&ser), _peripher_power(peripher_power), _pin_reset(pin_reset), _pin_en(pin_en) {
|
||||
@@ -76,6 +113,7 @@ public :
|
||||
}
|
||||
|
||||
void begin() override {
|
||||
_begin_calls++;
|
||||
claim();
|
||||
if (_pin_en != -1) {
|
||||
digitalWrite(_pin_en, GPS_EN_ACTIVE);
|
||||
@@ -91,9 +129,15 @@ public :
|
||||
delay(10);
|
||||
digitalWrite(_pin_reset, !GPS_RESET_ACTIVE);
|
||||
}
|
||||
#ifdef GPS_L76K
|
||||
// EnvironmentSensorManager calls reset() immediately after begin().
|
||||
// Configure only after that reset so the setting is not discarded.
|
||||
configureL76K();
|
||||
#endif
|
||||
}
|
||||
|
||||
void stop() override {
|
||||
_stop_calls++;
|
||||
if (_pin_en != -1) {
|
||||
digitalWrite(_pin_en, !GPS_EN_ACTIVE);
|
||||
}
|
||||
@@ -129,18 +173,65 @@ public :
|
||||
return dt.unixtime();
|
||||
}
|
||||
|
||||
void drain() { while (_gps_serial->available()) _gps_serial->read(); }
|
||||
|
||||
const char* getSentence() const { return nmea.getSentence(); }
|
||||
|
||||
void sendSentence(const char *sentence) override {
|
||||
nmea.sendSentence(*_gps_serial, sentence);
|
||||
}
|
||||
|
||||
bool waitFor(const char* prefix, uint32_t timeout_ms) {
|
||||
size_t plen = strlen(prefix);
|
||||
uint32_t timeout = millis() + timeout_ms;
|
||||
while ((int32_t)(millis() - timeout) < 0) {
|
||||
if (_gps_serial->available()) {
|
||||
char c = _gps_serial->read();
|
||||
#ifdef GPS_NMEA_DEBUG
|
||||
Serial.print(c);
|
||||
#endif
|
||||
if (nmea.process(c) && strncmp(nmea.getSentence(), prefix, plen) == 0) return true;
|
||||
} else {
|
||||
yield();
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void loop() override {
|
||||
|
||||
while (_gps_serial->available()) {
|
||||
char c = _gps_serial->read();
|
||||
_uart_bytes++;
|
||||
_last_uart_ms = millis();
|
||||
_uart_seen = true;
|
||||
#ifdef GPS_NMEA_DEBUG
|
||||
Serial.print(c);
|
||||
#endif
|
||||
nmea.process(c);
|
||||
bool parsed = nmea.process(c);
|
||||
|
||||
// MicroNMEA leaves the completed sentence in its buffer after the
|
||||
// first line terminator. CRLF therefore counts once: CR observes the
|
||||
// sentence, then LF clears the now-empty buffer.
|
||||
if ((c == '\0' || c == '\r' || c == '\n') && nmea.getSentence()[0] != '\0') {
|
||||
if (MicroNMEA::testChecksum(nmea.getSentence())) {
|
||||
_nmea_checksum_ok++;
|
||||
_last_nmea_ms = millis();
|
||||
_nmea_seen = true;
|
||||
|
||||
// Refresh fix age only when a newly parsed GGA/RMC sentence
|
||||
// carries a valid fix. Other valid NMEA sentences must not
|
||||
// make an old position look fresh.
|
||||
const char* message_id = nmea.getMessageID();
|
||||
if (parsed && isValid() &&
|
||||
(strcmp(message_id, "GGA") == 0 || strcmp(message_id, "RMC") == 0)) {
|
||||
_last_fix_ms = millis();
|
||||
_fix_seen = true;
|
||||
}
|
||||
} else {
|
||||
_nmea_checksum_bad++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!isValid()) time_valid = 0;
|
||||
@@ -163,4 +254,31 @@ public :
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void formatDiagnostics(char* out, size_t out_size) override {
|
||||
if (out_size == 0) return;
|
||||
|
||||
char uart_age[11];
|
||||
char nmea_age[11];
|
||||
char fix_age[11];
|
||||
formatAge(uart_age, sizeof(uart_age), _uart_seen, _last_uart_ms);
|
||||
formatAge(nmea_age, sizeof(nmea_age), _nmea_seen, _last_nmea_ms);
|
||||
formatAge(fix_age, sizeof(fix_age), _fix_seen, _last_fix_ms);
|
||||
|
||||
// Compact enough for CommonCLI's 160-byte reply buffer, including the
|
||||
// "req:" prefix added by CommonCLI.
|
||||
snprintf(out, out_size,
|
||||
"en:%u ub:%lu ua:%s ok:%lu bad:%lu na:%s sat:%ld fix:%u fa:%s bc:%lu sc:%lu",
|
||||
isEnabled() ? 1U : 0U,
|
||||
(unsigned long)_uart_bytes,
|
||||
uart_age,
|
||||
(unsigned long)_nmea_checksum_ok,
|
||||
(unsigned long)_nmea_checksum_bad,
|
||||
nmea_age,
|
||||
satellitesCount(),
|
||||
isValid() ? 1U : 0U,
|
||||
fix_age,
|
||||
(unsigned long)_begin_calls,
|
||||
(unsigned long)_stop_calls);
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,45 @@
|
||||
#include "AutoDetectDisplay.h"
|
||||
#include <MeshCore.h>
|
||||
|
||||
int AutoDetectDisplay::getDisplayStatus(TwoWire& wire, uint8_t addr) {
|
||||
int status = -1;
|
||||
for(int i = 0; i < 4; i++){
|
||||
|
||||
// request display status
|
||||
wire.beginTransmission(addr);
|
||||
wire.write((uint8_t)0x00);
|
||||
|
||||
// ensure response received
|
||||
if (wire.endTransmission() != 0) return -1; // expect success
|
||||
if (wire.requestFrom((int)addr, 1) == 0) return -1; // expect at least 1 byte
|
||||
|
||||
// ensure two consecutive reads are the same
|
||||
int previous = status;
|
||||
status = wire.read() & 0x0F;
|
||||
if(status == previous){
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
bool AutoDetectDisplay::begin() {
|
||||
|
||||
// request status from display address
|
||||
int status = getDisplayStatus(Wire, DISPLAY_ADDRESS);
|
||||
MESH_DEBUG_PRINTLN("AutoDetectDisplay: status=0x%02X", status);
|
||||
|
||||
// detect SH1106
|
||||
if(status == 0x00 || status == 0x08){
|
||||
MESH_DEBUG_PRINTLN("AutoDetectDisplay: SH1106 detected");
|
||||
_impl = &_sh1106;
|
||||
return _sh1106.begin();
|
||||
}
|
||||
|
||||
// fallback to SSD1306
|
||||
MESH_DEBUG_PRINTLN("AutoDetectDisplay: falling back to SSD1306");
|
||||
_impl = &_ssd1306;
|
||||
return _ssd1306.begin();
|
||||
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
#pragma once
|
||||
|
||||
#include "DisplayDriver.h"
|
||||
#include "SSD1306Display.h"
|
||||
#include "SH1106Display.h"
|
||||
|
||||
// Auto detects SH1106 display at runtime, otherwise falls back to using SSD1306
|
||||
class AutoDetectDisplay : public DisplayDriver {
|
||||
DisplayDriver* _impl;
|
||||
SSD1306Display _ssd1306;
|
||||
SH1106Display _sh1106;
|
||||
|
||||
int getDisplayStatus(TwoWire& wire, uint8_t addr);
|
||||
public:
|
||||
AutoDetectDisplay() : DisplayDriver(128, 64), _impl(&_ssd1306) { }
|
||||
bool begin();
|
||||
|
||||
bool isOn() override { return _impl->isOn(); }
|
||||
void turnOn() override { _impl->turnOn(); }
|
||||
void turnOff() override { _impl->turnOff(); }
|
||||
void clear() override { _impl->clear(); }
|
||||
void startFrame(ColorVal bkg = UIColor::window_bkg) override { _impl->startFrame(bkg); }
|
||||
void setTextSize(int sz) override { _impl->setTextSize(sz); }
|
||||
void setColor(ColorVal c) override { _impl->setColor(c); }
|
||||
void setCursor(int x, int y) override { _impl->setCursor(x, y); }
|
||||
void print(const char* str) override { _impl->print(str); }
|
||||
void fillRect(int x, int y, int w, int h) override { _impl->fillRect(x, y, w, h); }
|
||||
void drawRect(int x, int y, int w, int h) override { _impl->drawRect(x, y, w, h); }
|
||||
void drawXbm(int x, int y, const uint8_t* bits, int w, int h) override { _impl->drawXbm(x, y, bits, w, h); }
|
||||
uint16_t getTextWidth(const char* str) override { return _impl->getTextWidth(str); }
|
||||
void endFrame() override { _impl->endFrame(); }
|
||||
};
|
||||
@@ -25,7 +25,9 @@ public:
|
||||
virtual bool isEink() { return false; } // default to non-eink, override in eink drivers
|
||||
virtual void forceFullRefresh() {} // next refresh will be full for eink
|
||||
virtual void turnOn() = 0;
|
||||
virtual void turnOn(int max_partial) { turnOn(); }
|
||||
virtual void turnOff() = 0;
|
||||
virtual void turnOff(bool blank) { turnOff(); }
|
||||
virtual void clear() = 0;
|
||||
virtual void startFrame(ColorVal bkg = UIColor::window_bkg) = 0;
|
||||
virtual void setTextSize(int sz) = 0;
|
||||
|
||||
@@ -1,11 +1,6 @@
|
||||
|
||||
#include "GxEPDDisplay.h"
|
||||
|
||||
#ifdef EXP_PIN_BACKLIGHT
|
||||
#include <PCA9557.h>
|
||||
extern PCA9557 expander;
|
||||
#endif
|
||||
|
||||
#ifndef DISPLAY_ROTATION
|
||||
#define DISPLAY_ROTATION 3
|
||||
#endif
|
||||
@@ -52,7 +47,7 @@ bool GxEPDDisplay::begin() {
|
||||
}
|
||||
|
||||
display.setPartialWindow(0, 0, display.width(), display.height());
|
||||
resetPartialRefreshCounter();
|
||||
_partial_refresh_count = 0;
|
||||
|
||||
#if DISP_BACKLIGHT
|
||||
digitalWrite(DISP_BACKLIGHT, LOW);
|
||||
@@ -65,29 +60,55 @@ bool GxEPDDisplay::begin() {
|
||||
|
||||
void GxEPDDisplay::turnOn() {
|
||||
if (!_init) begin();
|
||||
#if defined(DISP_BACKLIGHT) && !defined(BACKLIGHT_BTN)
|
||||
digitalWrite(DISP_BACKLIGHT, HIGH);
|
||||
#elif defined(EXP_PIN_BACKLIGHT) && !defined(BACKLIGHT_BTN)
|
||||
expander.digitalWrite(EXP_PIN_BACKLIGHT, HIGH);
|
||||
#endif
|
||||
if (!_isOn) {
|
||||
_isOn = true;
|
||||
}
|
||||
}
|
||||
|
||||
void GxEPDDisplay::turnOff() {
|
||||
#if defined(DISP_BACKLIGHT) && !defined(BACKLIGHT_BTN)
|
||||
digitalWrite(DISP_BACKLIGHT, LOW);
|
||||
#elif defined(EXP_PIN_BACKLIGHT) && !defined(BACKLIGHT_BTN)
|
||||
expander.digitalWrite(EXP_PIN_BACKLIGHT, LOW);
|
||||
#endif
|
||||
void GxEPDDisplay::turnOn(int max_partial) {
|
||||
setMaxPartialRefresh(max_partial);
|
||||
turnOn();
|
||||
}
|
||||
|
||||
// 24x24 sleep icon, MSB-first (matches GxEPDDisplay::drawXbm)
|
||||
static const uint8_t sleep_icon_24x24[] = {
|
||||
0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xe0, 0x0e, 0x03, 0xc0, 0x18,
|
||||
0x0f, 0x80, 0x70, 0x1f, 0x80, 0xff, 0x3f, 0x80, 0xff, 0x3f, 0x00, 0x00,
|
||||
0x7f, 0x3f, 0x00, 0x7f, 0x3f, 0x00, 0xff, 0x0e, 0x00, 0xff, 0x1c, 0x7c,
|
||||
0xff, 0xbf, 0x7c, 0xff, 0xbf, 0x38, 0xff, 0xc0, 0x7c, 0xff, 0xe0, 0x7c,
|
||||
0xff, 0xf0, 0x00, 0x7f, 0xfc, 0x00, 0x7f, 0xff, 0xf8, 0x3f, 0xff, 0xf0,
|
||||
0x1f, 0xff, 0xf0, 0x0f, 0xff, 0xe0, 0x07, 0xff, 0x80, 0x01, 0xff, 0x00
|
||||
};
|
||||
|
||||
void GxEPDDisplay::drawSleepIcon() {
|
||||
const int W = 24, H = 24;
|
||||
int x = (int)(display.width() / scale_x) - W; // top-right, logical coordinates
|
||||
int y = 0;
|
||||
|
||||
display.fillRect((x - 5) * scale_x - 1, y * scale_y, (W+5) * scale_x + 2, (H-2) * scale_y + 1, GxEPD_WHITE);
|
||||
_curr_color = GxEPD_BLACK;
|
||||
drawXbm(x, y, sleep_icon_24x24, W, H);
|
||||
display.display(true);
|
||||
}
|
||||
|
||||
void GxEPDDisplay::turnOff(bool blank) {
|
||||
if (blank) {
|
||||
blankScreen();
|
||||
} else {
|
||||
drawSleepIcon();
|
||||
}
|
||||
_isOn = false;
|
||||
last_display_crc_value=0;
|
||||
}
|
||||
|
||||
void GxEPDDisplay::blankScreen() {
|
||||
// do full refresh before powering off to clear screen
|
||||
// no full refresh needed at wakeup
|
||||
display.clearScreen(0xFF); // Clears microcontroller side RAM
|
||||
display.writeScreenBuffer(0xFF); // Forces 0xFF (White) into the display controller's history registers
|
||||
resetPartialRefreshCounter();
|
||||
last_display_crc_value=0;
|
||||
_partial_refresh_count = 0;
|
||||
last_display_crc_value = 0;
|
||||
// we can hibernate as screen has been cleaned
|
||||
display.hibernate();
|
||||
}
|
||||
|
||||
@@ -101,15 +122,18 @@ void GxEPDDisplay::startFrame(ColorVal bkg) {
|
||||
display.fillScreen(bkg);
|
||||
display.setTextColor(_curr_color = UIColor::primary_txt);
|
||||
display_crc.reset();
|
||||
if (_cycles_before_full_refresh != 0) {
|
||||
display.setPartialWindow(0, 0, display.width(), display.height());
|
||||
} else {
|
||||
if (_force_full_refresh
|
||||
|| (_max_partial_refresh > 0
|
||||
&& _partial_refresh_count >= _max_partial_refresh)) {
|
||||
// forces a full wipe of the screen ...
|
||||
display.clearScreen(0xFF); // Clears microcontroller side RAM
|
||||
display.writeScreenBuffer(0xFF); // Forces 0xFF (White) into the display controller's history registers
|
||||
// we'll need a partial refresh after that (whatever crc value is)
|
||||
last_display_crc_value = 0;
|
||||
resetPartialRefreshCounter();
|
||||
_partial_refresh_count = 0;
|
||||
_force_full_refresh = false;
|
||||
} else {
|
||||
display.setPartialWindow(0, 0, display.width(), display.height());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -216,9 +240,7 @@ void GxEPDDisplay::endFrame() {
|
||||
uint32_t crc = display_crc.finalize();
|
||||
if (crc != last_display_crc_value) {
|
||||
display.display(true);
|
||||
if (_cycles_before_full_refresh > 0) {
|
||||
_cycles_before_full_refresh--;
|
||||
}
|
||||
_partial_refresh_count++;
|
||||
}
|
||||
last_display_crc_value = crc;
|
||||
}
|
||||
@@ -16,12 +16,6 @@
|
||||
|
||||
#include "DisplayDriver.h"
|
||||
|
||||
#ifndef EINK_MAX_PARTIAL_REFRESH
|
||||
// 60 to prevent ghosting when refreshing every minute ...
|
||||
// set to -1 to disable the counter
|
||||
#define EINK_MAX_PARTIAL_REFRESH -1
|
||||
#endif
|
||||
|
||||
class GxEPDDisplay : public DisplayDriver {
|
||||
|
||||
#if defined(EINK_DISPLAY_MODEL)
|
||||
@@ -42,8 +36,9 @@ class GxEPDDisplay : public DisplayDriver {
|
||||
uint16_t _curr_color;
|
||||
CRC32 display_crc;
|
||||
int last_display_crc_value = 0;
|
||||
int _cycles_before_full_refresh;
|
||||
int max_partial_refresh = EINK_MAX_PARTIAL_REFRESH; // so this can be changed by an option after
|
||||
bool _force_full_refresh = false;
|
||||
int _partial_refresh_count = 0;
|
||||
int _max_partial_refresh = 0;
|
||||
|
||||
public:
|
||||
#if defined(EINK_DISPLAY_MODEL)
|
||||
@@ -56,10 +51,13 @@ public:
|
||||
|
||||
bool isOn() override { return _isOn; }
|
||||
bool isEink() override { return true; }
|
||||
void forceFullRefresh() override { _cycles_before_full_refresh = 0; };
|
||||
void resetPartialRefreshCounter() { _cycles_before_full_refresh = max_partial_refresh; };
|
||||
void forceFullRefresh() override { _force_full_refresh = true; }
|
||||
void turnOn(int max_partial) override;
|
||||
void turnOn() override;
|
||||
void turnOff() override;
|
||||
void turnOff(bool blank) override;
|
||||
void turnOff() override { turnOff(false); }
|
||||
virtual void blankScreen();
|
||||
virtual void setMaxPartialRefresh(int count) {_max_partial_refresh = count; }
|
||||
void clear() override;
|
||||
void startFrame(ColorVal bkg = UIColor::window_bkg) override;
|
||||
void setTextSize(int sz) override;
|
||||
@@ -69,6 +67,7 @@ public:
|
||||
void fillRect(int x, int y, int w, int h) override;
|
||||
void drawRect(int x, int y, int w, int h) override;
|
||||
void drawXbm(int x, int y, const uint8_t* bits, int w, int h) override;
|
||||
void drawSleepIcon();
|
||||
uint16_t getTextWidth(const char* str) override;
|
||||
void endFrame() override;
|
||||
};
|
||||
@@ -10,15 +10,15 @@ bool SH1106Display::i2c_probe(TwoWire &wire, uint8_t addr)
|
||||
}
|
||||
|
||||
// Color scheme
|
||||
ColorVal UIColor::window_bkg = SH110X_BLACK;
|
||||
ColorVal UIColor::title_bkg = SH110X_BLACK;
|
||||
ColorVal UIColor::title_txt = SH110X_WHITE;
|
||||
ColorVal UIColor::primary_txt = SH110X_WHITE;
|
||||
ColorVal UIColor::secondary_txt = SH110X_WHITE;
|
||||
ColorVal UIColor::warning_txt = SH110X_WHITE;
|
||||
ColorVal UIColor::popup_bkg = SH110X_BLACK;
|
||||
ColorVal UIColor::popup_txt = SH110X_WHITE;
|
||||
ColorVal UIColor::corp_blue = SH110X_WHITE;
|
||||
__attribute__((weak)) ColorVal UIColor::window_bkg = SH110X_BLACK;
|
||||
__attribute__((weak)) ColorVal UIColor::title_bkg = SH110X_BLACK;
|
||||
__attribute__((weak)) ColorVal UIColor::title_txt = SH110X_WHITE;
|
||||
__attribute__((weak)) ColorVal UIColor::primary_txt = SH110X_WHITE;
|
||||
__attribute__((weak)) ColorVal UIColor::secondary_txt = SH110X_WHITE;
|
||||
__attribute__((weak)) ColorVal UIColor::warning_txt = SH110X_WHITE;
|
||||
__attribute__((weak)) ColorVal UIColor::popup_bkg = SH110X_BLACK;
|
||||
__attribute__((weak)) ColorVal UIColor::popup_txt = SH110X_WHITE;
|
||||
__attribute__((weak)) ColorVal UIColor::corp_blue = SH110X_WHITE;
|
||||
|
||||
bool SH1106Display::begin()
|
||||
{
|
||||
|
||||
@@ -0,0 +1,230 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include <cstring>
|
||||
#include <ed_25519.h>
|
||||
|
||||
#include "Dispatcher.cpp"
|
||||
#include "Mesh.cpp"
|
||||
#include "helpers/AdvertDataHelpers.cpp"
|
||||
#include "helpers/BaseChatMesh.cpp"
|
||||
|
||||
void StrHelper::strncpy(char* dest, const char* src, size_t buf_sz) {
|
||||
if (buf_sz == 0) return;
|
||||
std::strncpy(dest, src, buf_sz - 1);
|
||||
dest[buf_sz - 1] = 0;
|
||||
}
|
||||
|
||||
namespace mesh {
|
||||
|
||||
Identity::Identity() {
|
||||
memset(pub_key, 0, sizeof(pub_key));
|
||||
}
|
||||
|
||||
bool Identity::verify(const uint8_t*, const uint8_t*, int) const {
|
||||
return true;
|
||||
}
|
||||
|
||||
LocalIdentity::LocalIdentity() : Identity() {
|
||||
memset(prv_key, 0, sizeof(prv_key));
|
||||
}
|
||||
|
||||
void LocalIdentity::sign(uint8_t* sig, const uint8_t*, int) const {
|
||||
memset(sig, 0, SIGNATURE_SIZE);
|
||||
}
|
||||
|
||||
void LocalIdentity::calcSharedSecret(uint8_t* secret, const uint8_t* other_pub_key) const {
|
||||
ed25519_key_exchange(secret, other_pub_key, prv_key);
|
||||
}
|
||||
|
||||
} // namespace mesh
|
||||
|
||||
namespace {
|
||||
|
||||
class DummyRadio : public mesh::Radio {
|
||||
public:
|
||||
int recvRaw(uint8_t*, int) override { return 0; }
|
||||
uint32_t getEstAirtimeFor(int) override { return 10; }
|
||||
float packetScore(float, int) override { return 1.0f; }
|
||||
bool startSendRaw(const uint8_t*, int) override { return true; }
|
||||
bool isSendComplete() override { return true; }
|
||||
void onSendFinished() override {}
|
||||
bool isInRecvMode() const override { return true; }
|
||||
};
|
||||
|
||||
class DummyMillisecondClock : public mesh::MillisecondClock {
|
||||
public:
|
||||
unsigned long getMillis() override { return 1000; }
|
||||
};
|
||||
|
||||
class DummyRNG : public mesh::RNG {
|
||||
public:
|
||||
void random(uint8_t* dest, size_t len) override { memset(dest, 0x42, len); }
|
||||
};
|
||||
|
||||
class DummyRTCClock : public mesh::RTCClock {
|
||||
uint32_t _now = 1700000000;
|
||||
public:
|
||||
uint32_t getCurrentTime() override { return _now; }
|
||||
void setCurrentTime(uint32_t time) override { _now = time; }
|
||||
};
|
||||
|
||||
class DummyPacketManager : public mesh::PacketManager {
|
||||
public:
|
||||
mesh::Packet* allocNew() override { return nullptr; }
|
||||
void free(mesh::Packet*) override {}
|
||||
void queueOutbound(mesh::Packet*, uint8_t, uint32_t) override {}
|
||||
mesh::Packet* getNextOutbound(uint32_t) override { return nullptr; }
|
||||
int getOutboundCount(uint32_t) const override { return 0; }
|
||||
int getOutboundTotal() const override { return 0; }
|
||||
int getFreeCount() const override { return 16; }
|
||||
mesh::Packet* getOutboundByIdx(int) override { return nullptr; }
|
||||
mesh::Packet* removeOutboundByIdx(int) override { return nullptr; }
|
||||
void queueInbound(mesh::Packet*, uint32_t) override {}
|
||||
mesh::Packet* getNextInbound(uint32_t) override { return nullptr; }
|
||||
};
|
||||
|
||||
class DummyMeshTables : public mesh::MeshTables {
|
||||
public:
|
||||
bool wasSeen(const mesh::Packet*) override { return false; }
|
||||
void markSeen(const mesh::Packet*) override {}
|
||||
void clear(const mesh::Packet*) override {}
|
||||
};
|
||||
|
||||
class TestChatMesh : public BaseChatMesh {
|
||||
public:
|
||||
int messages_received = 0;
|
||||
|
||||
TestChatMesh(mesh::Radio& radio, mesh::MillisecondClock& ms, mesh::RNG& rng,
|
||||
mesh::RTCClock& rtc, mesh::PacketManager& mgr, mesh::MeshTables& tables)
|
||||
: BaseChatMesh(radio, ms, rng, rtc, mgr, tables) {}
|
||||
|
||||
void onDiscoveredContact(ContactInfo&, bool, uint8_t, const uint8_t*) override {}
|
||||
ContactInfo* processAck(const uint8_t*) override { return nullptr; }
|
||||
void onContactPathUpdated(const ContactInfo&) override {}
|
||||
void onMessageRecv(const ContactInfo&, mesh::Packet*, uint32_t, const char*) override {
|
||||
messages_received++;
|
||||
}
|
||||
void onCommandDataRecv(const ContactInfo&, mesh::Packet*, uint32_t, const char*) override {}
|
||||
void onCLICommandRecv(const ContactInfo&, mesh::Packet*, uint32_t, const char*, char*) override {}
|
||||
void onSignedMessageRecv(const ContactInfo&, mesh::Packet*, uint32_t, const uint8_t*, const char*) override {}
|
||||
void onChannelMessageRecv(const mesh::GroupChannel&, mesh::Packet*, uint32_t, const char*) override {}
|
||||
uint8_t onContactRequest(const ContactInfo&, uint32_t, const uint8_t*, uint8_t, uint8_t*) override { return 0; }
|
||||
void onContactResponse(const ContactInfo&, const uint8_t*, uint8_t) override {}
|
||||
uint32_t calcFloodTimeoutMillisFor(uint32_t) const override { return 1000; }
|
||||
uint32_t calcDirectTimeoutMillisFor(uint32_t, uint8_t) const override { return 1000; }
|
||||
void onSendTimeout() override {}
|
||||
|
||||
using BaseChatMesh::resetContacts;
|
||||
using BaseChatMesh::searchPeersByHash;
|
||||
using BaseChatMesh::getPeerSharedSecret;
|
||||
using mesh::Mesh::onRecvPacket;
|
||||
};
|
||||
|
||||
struct MeshFixture {
|
||||
DummyRadio radio;
|
||||
DummyMillisecondClock ms;
|
||||
DummyRNG rng;
|
||||
DummyRTCClock rtc;
|
||||
DummyPacketManager mgr;
|
||||
DummyMeshTables tables;
|
||||
TestChatMesh chat{radio, ms, rng, rtc, mgr, tables};
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(EmptyContactSlots, ZeroPubKeyProducesAllZeroSharedSecretForAnyPrivateKey) {
|
||||
ContactInfo empty_slot;
|
||||
memset(&empty_slot, 0, sizeof(empty_slot));
|
||||
EXPECT_TRUE(empty_slot.isEmptySlot());
|
||||
|
||||
uint8_t raw_prv[PRV_KEY_SIZE];
|
||||
for (int i = 0; i < PRV_KEY_SIZE; i++) {
|
||||
raw_prv[i] = static_cast<uint8_t>(0xA5 ^ (i * 13 + 7));
|
||||
}
|
||||
uint8_t secret[PUB_KEY_SIZE];
|
||||
ed25519_key_exchange(secret, empty_slot.id.pub_key, raw_prv);
|
||||
|
||||
uint8_t expected_zeroes[PUB_KEY_SIZE] = { 0 };
|
||||
EXPECT_EQ(0, memcmp(secret, expected_zeroes, PUB_KEY_SIZE));
|
||||
}
|
||||
|
||||
TEST(EmptyContactSlots, NullKeyPeerPacketIsRejectedWhenAnonSlotsAreEmpty) {
|
||||
MeshFixture fx;
|
||||
fx.chat.self_id.pub_key[0] = 0x42;
|
||||
|
||||
// Craft a PAYLOAD_TYPE_TXT_MSG addressed to self_id (dest_hash=0x42) with src_hash=0x00,
|
||||
// encrypted and MAC'd under the all-zero 32-byte key that an empty ContactInfo slot derives.
|
||||
uint8_t zero_secret[PUB_KEY_SIZE] = { 0 };
|
||||
uint8_t plaintext[16] = { 0 };
|
||||
uint32_t ts = 1700000001;
|
||||
memcpy(plaintext, &ts, 4);
|
||||
plaintext[4] = (TXT_TYPE_PLAIN << 2);
|
||||
strcpy(reinterpret_cast<char*>(&plaintext[5]), "forged");
|
||||
|
||||
mesh::Packet pkt;
|
||||
pkt.header = ROUTE_TYPE_FLOOD | (PAYLOAD_TYPE_TXT_MSG << PH_TYPE_SHIFT);
|
||||
pkt.path_len = 0;
|
||||
pkt.payload[0] = 0x42; // dest_hash (matches fx.chat.self_id)
|
||||
pkt.payload[1] = 0x00; // src_hash (matches all-zero pub_key if empty slots are not skipped)
|
||||
int enc_len = mesh::Utils::encryptThenMAC(zero_secret, &pkt.payload[2], plaintext, 12);
|
||||
pkt.payload_len = static_cast<uint8_t>(2 + enc_len);
|
||||
|
||||
fx.chat.onRecvPacket(&pkt);
|
||||
EXPECT_EQ(0, fx.chat.messages_received);
|
||||
}
|
||||
|
||||
TEST(EmptyContactSlots, SearchPeersByHashSkipsEmptyAnonSlotsAndFindsRealZeroPrefixPeer) {
|
||||
MeshFixture fx;
|
||||
const uint8_t zero_hash = 0x00;
|
||||
|
||||
// Freshly reset contacts has MAX_ANON_CONTACTS (8) zeroed transient slots.
|
||||
EXPECT_EQ(0, fx.chat.searchPeersByHash(&zero_hash));
|
||||
|
||||
// Add a legitimate permanent contact whose public key starts with 0x00.
|
||||
ContactInfo peer;
|
||||
memset(&peer, 0, sizeof(peer));
|
||||
peer.type = ADV_TYPE_CHAT;
|
||||
peer.lastmod = 1700000100;
|
||||
strcpy(peer.name, "Alice");
|
||||
peer.id.pub_key[0] = 0x00;
|
||||
for (int i = 1; i < PUB_KEY_SIZE; i++) {
|
||||
peer.id.pub_key[i] = static_cast<uint8_t>(i);
|
||||
}
|
||||
ASSERT_TRUE(fx.chat.addContact(peer));
|
||||
|
||||
// Only the populated contact at index MAX_ANON_CONTACTS should match.
|
||||
EXPECT_EQ(1, fx.chat.searchPeersByHash(&zero_hash));
|
||||
|
||||
// Lookup by pubkey and name prefix must also skip the empty transient slots.
|
||||
uint8_t zero_prefix[6] = { 0 };
|
||||
EXPECT_EQ(nullptr, fx.chat.lookupContactByPubKey(zero_prefix, sizeof(zero_prefix)));
|
||||
|
||||
ContactInfo* found = fx.chat.lookupContactByPubKey(peer.id.pub_key, 6);
|
||||
ASSERT_NE(nullptr, found);
|
||||
EXPECT_STREQ("Alice", found->name);
|
||||
|
||||
ContactInfo* by_name = fx.chat.searchContactsByPrefix("");
|
||||
ASSERT_NE(nullptr, by_name);
|
||||
EXPECT_STREQ("Alice", by_name->name);
|
||||
}
|
||||
|
||||
TEST(EmptyContactSlots, PopulatedTransientAnonSlotStillMatchesEvenWhenLastmodIsZero) {
|
||||
MeshFixture fx;
|
||||
const uint8_t zero_hash = 0x00;
|
||||
|
||||
ContactInfo anon;
|
||||
memset(&anon, 0, sizeof(anon));
|
||||
anon.type = ADV_TYPE_NONE;
|
||||
anon.lastmod = 0; // e.g. RTC not yet initialised on nRF52
|
||||
anon.id.pub_key[0] = 0x00;
|
||||
anon.id.pub_key[1] = 0x7F;
|
||||
ASSERT_TRUE(fx.chat.addContact(anon));
|
||||
|
||||
EXPECT_FALSE(anon.isEmptySlot());
|
||||
EXPECT_EQ(1, fx.chat.searchPeersByHash(&zero_hash));
|
||||
EXPECT_NE(nullptr, fx.chat.lookupContactByPubKey(anon.id.pub_key, PUB_KEY_SIZE));
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
@@ -8,6 +8,9 @@ static Packet makeFlood(uint8_t route_type, uint8_t payload_type, uint8_t hops)
|
||||
p.header = route_type | (payload_type << PH_TYPE_SHIFT);
|
||||
p.setPathHashSizeAndCount(1, hops);
|
||||
p.payload_len = 1;
|
||||
if (route_type == ROUTE_TYPE_TRANSPORT_FLOOD) {
|
||||
p.transport_codes[0] = 1; // has to be non-zero
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
@@ -7,7 +7,6 @@ build_flags = ${nrf52_base.build_flags}
|
||||
-I variants/gat562_30s_mesh_kit
|
||||
-D RAK_4631
|
||||
-D RAK_BOARD
|
||||
-D NRF52_POWER_MANAGEMENT
|
||||
-D PIN_BOARD_SCL=14
|
||||
-D PIN_BOARD_SDA=13
|
||||
-D PIN_OLED_RESET=-1
|
||||
|
||||
@@ -5,7 +5,6 @@ board_check = true
|
||||
build_flags = ${nrf52_base.build_flags}
|
||||
${sensor_base.build_flags}
|
||||
-I variants/gat562_mesh_evb_pro
|
||||
-D NRF52_POWER_MANAGEMENT
|
||||
-D PIN_BOARD_SCL=14
|
||||
-D PIN_BOARD_SDA=13
|
||||
-D RADIO_CLASS=CustomSX1262
|
||||
|
||||
@@ -5,7 +5,6 @@ board_check = true
|
||||
build_flags = ${nrf52_base.build_flags}
|
||||
${sensor_base.build_flags}
|
||||
-I variants/gat562_mesh_tracker_pro
|
||||
-D NRF52_POWER_MANAGEMENT
|
||||
-D PIN_BOARD_SCL=14
|
||||
-D PIN_BOARD_SDA=13
|
||||
-D PIN_OLED_RESET=-1
|
||||
|
||||
@@ -8,7 +8,6 @@ build_flags = ${nrf52_base.build_flags}
|
||||
-I variants/gat562_mesh_watch13
|
||||
-D RAK_4631
|
||||
-D RAK_BOARD
|
||||
-D NRF52_POWER_MANAGEMENT
|
||||
-D PIN_BOARD_SCL=14
|
||||
-D PIN_BOARD_SDA=13
|
||||
-D PIN_OLED_RESET=-1
|
||||
|
||||
@@ -9,7 +9,6 @@ build_flags = ${nrf52_base.build_flags}
|
||||
-I variants/heltec_t096
|
||||
-I src/helpers/ui
|
||||
-D HELTEC_T096
|
||||
-D NRF52_POWER_MANAGEMENT
|
||||
-D P_LORA_DIO_1=21
|
||||
-D P_LORA_NSS=5
|
||||
-D P_LORA_RESET=16
|
||||
|
||||
@@ -9,6 +9,12 @@
|
||||
#define USE_LFXO
|
||||
#define VARIANT_MCK (64000000ul)
|
||||
|
||||
// This board has no external RTC chip -- the ICM-42607-P IMU sits at 0x68,
|
||||
// the same I2C address DS3231 probing checks, so without this the IMU gets
|
||||
// misidentified as a DS3231 and its unrelated registers get read/written
|
||||
// as if they were time/status registers, producing a bogus, unfixable clock.
|
||||
#define DISABLE_DS3231_PROBE
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Number of pins
|
||||
|
||||
|
||||
@@ -12,7 +12,6 @@ build_flags = ${nrf52_base.build_flags}
|
||||
-I variants/heltec_t114
|
||||
-I src/helpers/ui
|
||||
-D HELTEC_T114
|
||||
-D NRF52_POWER_MANAGEMENT
|
||||
-D P_LORA_DIO_1=20
|
||||
-D P_LORA_NSS=24
|
||||
-D P_LORA_RESET=25
|
||||
|
||||
@@ -168,12 +168,14 @@ build_flags =
|
||||
-D AUTO_SHUTDOWN_MILLIVOLTS=3400
|
||||
-D BLE_DEBUG_LOGGING=1
|
||||
-D OFFLINE_QUEUE_SIZE=256
|
||||
-D ENABLE_WIFI_INTERFACE
|
||||
; -D MESH_PACKET_LOGGING=1
|
||||
; -D MESH_DEBUG=1
|
||||
build_src_filter = ${Heltec_lora32_v3.build_src_filter}
|
||||
+<helpers/ui/SSD1306Display.cpp>
|
||||
+<helpers/ui/MomentaryButton.cpp>
|
||||
+<helpers/esp32/*.cpp>
|
||||
+<helpers/wifi/*.cpp>
|
||||
+<../examples/companion_radio/*.cpp>
|
||||
+<../examples/companion_radio/ui-new/*.cpp>
|
||||
lib_deps =
|
||||
@@ -312,12 +314,14 @@ build_flags =
|
||||
-D MAX_CONTACTS=350
|
||||
-D MAX_GROUP_CHANNELS=40
|
||||
-D BLE_PIN_CODE=123456
|
||||
-D BLE_DEBUG_LOGGING=1
|
||||
-D OFFLINE_QUEUE_SIZE=256
|
||||
-D ENABLE_WIFI_INTERFACE
|
||||
; -D BLE_DEBUG_LOGGING=1
|
||||
; -D MESH_PACKET_LOGGING=1
|
||||
; -D MESH_DEBUG=1
|
||||
build_src_filter = ${Heltec_lora32_v3.build_src_filter}
|
||||
+<helpers/esp32/*.cpp>
|
||||
+<helpers/wifi/*.cpp>
|
||||
+<../examples/companion_radio/*.cpp>
|
||||
lib_deps =
|
||||
${Heltec_lora32_v3.lib_deps}
|
||||
|
||||
@@ -211,12 +211,14 @@ build_flags =
|
||||
-D AUTO_SHUTDOWN_MILLIVOLTS=3400
|
||||
-D BLE_DEBUG_LOGGING=1
|
||||
-D OFFLINE_QUEUE_SIZE=256
|
||||
-D ENABLE_WIFI_INTERFACE
|
||||
; -D MESH_PACKET_LOGGING=1
|
||||
; -D MESH_DEBUG=1
|
||||
build_src_filter = ${heltec_v4_oled.build_src_filter}
|
||||
+<helpers/ui/SSD1306Display.cpp>
|
||||
+<helpers/ui/MomentaryButton.cpp>
|
||||
+<helpers/esp32/*.cpp>
|
||||
+<helpers/wifi/*.cpp>
|
||||
+<../examples/companion_radio/*.cpp>
|
||||
+<../examples/companion_radio/ui-new/*.cpp>
|
||||
lib_deps =
|
||||
@@ -378,12 +380,14 @@ build_flags =
|
||||
-D AUTO_SHUTDOWN_MILLIVOLTS=3400
|
||||
-D BLE_DEBUG_LOGGING=1
|
||||
-D OFFLINE_QUEUE_SIZE=256
|
||||
-D ENABLE_WIFI_INTERFACE
|
||||
; -D MESH_PACKET_LOGGING=1
|
||||
; -D MESH_DEBUG=1
|
||||
build_src_filter = ${heltec_v4_tft.build_src_filter}
|
||||
+<helpers/ui/ST7789LCDDisplay.cpp>
|
||||
+<helpers/ui/MomentaryButton.cpp>
|
||||
+<helpers/esp32/*.cpp>
|
||||
+<helpers/wifi/*.cpp>
|
||||
+<../examples/companion_radio/*.cpp>
|
||||
+<../examples/companion_radio/ui-new/*.cpp>
|
||||
lib_deps =
|
||||
|
||||
@@ -160,10 +160,12 @@ build_flags =
|
||||
-D AUTO_SHUTDOWN_MILLIVOLTS=3400
|
||||
-D BLE_DEBUG_LOGGING=1
|
||||
-D OFFLINE_QUEUE_SIZE=256
|
||||
-D ENABLE_WIFI_INTERFACE
|
||||
build_src_filter = ${heltec_v4_r8_oled.build_src_filter}
|
||||
+<helpers/ui/SSD1306Display.cpp>
|
||||
+<helpers/ui/MomentaryButton.cpp>
|
||||
+<helpers/esp32/*.cpp>
|
||||
+<helpers/wifi/*.cpp>
|
||||
+<../examples/companion_radio/*.cpp>
|
||||
+<../examples/companion_radio/ui-new/*.cpp>
|
||||
lib_deps =
|
||||
|
||||
@@ -52,11 +52,13 @@ build_flags =
|
||||
-D MAX_GROUP_CHANNELS=40
|
||||
-D DISPLAY_CLASS=E213Display
|
||||
-D BLE_PIN_CODE=123456 ; dynamic, random PIN
|
||||
-D BLE_DEBUG_LOGGING=1
|
||||
-D OFFLINE_QUEUE_SIZE=256
|
||||
-D ENABLE_WIFI_INTERFACE
|
||||
; -D BLE_DEBUG_LOGGING=1
|
||||
build_src_filter = ${Heltec_Wireless_Paper_base.build_src_filter}
|
||||
+<helpers/ui/E213Display.cpp>
|
||||
+<helpers/esp32/*.cpp>
|
||||
+<helpers/wifi/*.cpp>
|
||||
+<../examples/companion_radio/*.cpp>
|
||||
+<../examples/companion_radio/ui-new/*.cpp>
|
||||
lib_deps =
|
||||
|
||||
@@ -9,7 +9,7 @@ protected:
|
||||
uint8_t btn_prev_state;
|
||||
|
||||
public:
|
||||
TImpulsePlusBoard() : NRF52Board("T-Impulse-Plus OTA") {}
|
||||
TImpulsePlusBoard() : NRF52Board("T-Impulse-Plus_OTA") {}
|
||||
void begin();
|
||||
|
||||
#if defined(P_LORA_TX_LED)
|
||||
|
||||
@@ -131,11 +131,13 @@ build_flags =
|
||||
-D MAX_GROUP_CHANNELS=40
|
||||
-D BLE_PIN_CODE=123456
|
||||
-D OFFLINE_QUEUE_SIZE=256
|
||||
-D ENABLE_WIFI_INTERFACE
|
||||
; -D BLE_DEBUG_LOGGING=1
|
||||
; -D MESH_PACKET_LOGGING=8
|
||||
; -D MESH_DEBUG=1
|
||||
build_src_filter = ${T_Beam_S3_Supreme_SX1262.build_src_filter}
|
||||
+<helpers/esp32/*.cpp>
|
||||
+<helpers/wifi/*.cpp>
|
||||
+<helpers/ui/MomentaryButton.cpp>
|
||||
+<../examples/companion_radio/*.cpp>
|
||||
+<../examples/companion_radio/ui-new/*.cpp>
|
||||
|
||||
@@ -32,8 +32,16 @@ build_flags = ${nrf52_base.build_flags}
|
||||
-D PIN_GPS_RESET_ACTIVE=LOW
|
||||
-D TELEM_BME280_ADDRESS=0x77
|
||||
-D DISPLAY_CLASS=GxEPDDisplay
|
||||
-D EINK_DISPLAY_MODEL=GxEPD2_154_D67
|
||||
-D EINK_SCALE_X=1.5625f
|
||||
-D EINK_SCALE_Y=1.5625f
|
||||
-D EINK_X_OFFSET=0
|
||||
-D EINK_Y_OFFSET=10
|
||||
-D EINK_SCREENOFF_BLANK
|
||||
-D UI_RECENT_LIST_SIZE=9
|
||||
-D UI_MSG_PREVIEW_SIZE=165
|
||||
-D AUTO_OFF_MILLIS=300000
|
||||
-D BACKLIGHT_BTN=PIN_BUTTON2
|
||||
-D AUTO_OFF_MILLIS=0
|
||||
build_src_filter = ${nrf52_base.build_src_filter}
|
||||
+<helpers/*.cpp>
|
||||
+<TechoBoard.cpp>
|
||||
@@ -91,7 +99,6 @@ build_flags =
|
||||
-D BLE_PIN_CODE=123456
|
||||
; -D BLE_DEBUG_LOGGING=1
|
||||
-D OFFLINE_QUEUE_SIZE=256
|
||||
-D UI_RECENT_LIST_SIZE=9
|
||||
-D UI_SENSORS_PAGE=1
|
||||
-D UI_GPS_PAGE=1
|
||||
; -D MESH_PACKET_LOGGING=1
|
||||
@@ -116,7 +123,6 @@ build_flags =
|
||||
-D MAX_CONTACTS=350
|
||||
-D MAX_GROUP_CHANNELS=40
|
||||
-D OFFLINE_QUEUE_SIZE=256
|
||||
-D UI_RECENT_LIST_SIZE=9
|
||||
-D UI_SENSORS_PAGE=1
|
||||
-D AUTO_SHUTDOWN_MILLIVOLTS=3300
|
||||
-D QSPIFLASH=1
|
||||
|
||||
@@ -23,6 +23,7 @@ EnvironmentSensorManager sensors = EnvironmentSensorManager();
|
||||
#ifdef DISPLAY_CLASS
|
||||
DISPLAY_CLASS display;
|
||||
MomentaryButton user_btn(PIN_USER_BTN, 1000, true);
|
||||
MomentaryButton backlight_btn(BACKLIGHT_BTN, 1000, true);
|
||||
#endif
|
||||
|
||||
bool radio_init() {
|
||||
|
||||
@@ -22,6 +22,7 @@ extern EnvironmentSensorManager sensors;
|
||||
#ifdef DISPLAY_CLASS
|
||||
extern DISPLAY_CLASS display;
|
||||
extern MomentaryButton user_btn;
|
||||
extern MomentaryButton backlight_btn;
|
||||
#endif
|
||||
|
||||
bool radio_init();
|
||||
|
||||
@@ -131,6 +131,12 @@ extern const int SCK;
|
||||
#define DISP_BUSY (3)
|
||||
#define DISP_BACKLIGHT (43)
|
||||
|
||||
// used by GxEPDDisplay when EINK_DISPLAY_MODEL is set
|
||||
#define PIN_DISPLAY_CS DISP_CS
|
||||
#define PIN_DISPLAY_DC DISP_DC
|
||||
#define PIN_DISPLAY_RST DISP_RST
|
||||
#define PIN_DISPLAY_BUSY DISP_BUSY
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// GPS
|
||||
|
||||
|
||||
@@ -98,6 +98,32 @@ lib_deps =
|
||||
${LilyGo_T-Echo-Lite.lib_deps}
|
||||
densaugeo/base64 @ ~1.4.0
|
||||
|
||||
[env:LilyGo_T-Echo-Lite_kiss_modem]
|
||||
extends = LilyGo_T-Echo-Lite
|
||||
build_src_filter = ${LilyGo_T-Echo-Lite.build_src_filter}
|
||||
+<../examples/kiss_modem/>
|
||||
[env:LilyGo_T-Echo-Lite_companion_radio_usb]
|
||||
extends = LilyGo_T-Echo-Lite
|
||||
board_build.ldscript = boards/nrf52840_s140_v6_extrafs.ld
|
||||
board_upload.maximum_size = 712704
|
||||
build_flags =
|
||||
${LilyGo_T-Echo-Lite.build_flags}
|
||||
-I src/helpers/ui
|
||||
-I examples/companion_radio/ui-new
|
||||
-D MAX_CONTACTS=350
|
||||
-D MAX_GROUP_CHANNELS=40
|
||||
-D OFFLINE_QUEUE_SIZE=256
|
||||
-D UI_RECENT_LIST_SIZE=9
|
||||
-D UI_SENSORS_PAGE=1
|
||||
-D AUTO_SHUTDOWN_MILLIVOLTS=3300
|
||||
; -D QSPIFLASH=1
|
||||
build_src_filter = ${LilyGo_T-Echo-Lite.build_src_filter}
|
||||
+<../examples/companion_radio/*.cpp>
|
||||
+<../examples/companion_radio/ui-new/*.cpp>
|
||||
lib_deps =
|
||||
${LilyGo_T-Echo-Lite.lib_deps}
|
||||
densaugeo/base64 @ ~1.4.0
|
||||
|
||||
[env:LilyGo_T-Echo-Lite_non_shell_companion_radio_ble]
|
||||
extends = LilyGo_T-Echo-Lite
|
||||
upload_protocol = nrfutil
|
||||
@@ -187,8 +213,3 @@ build_src_filter = ${nrf52_base.build_src_filter}
|
||||
lib_deps =
|
||||
${LilyGo_T-Echo-Lite.lib_deps}
|
||||
densaugeo/base64 @ ~1.4.0
|
||||
|
||||
[env:LilyGo_T-Echo-Lite_kiss_modem]
|
||||
extends = LilyGo_T-Echo-Lite
|
||||
build_src_filter = ${LilyGo_T-Echo-Lite.build_src_filter}
|
||||
+<../examples/kiss_modem/>
|
||||
@@ -70,9 +70,6 @@
|
||||
#define PIN_QSPI_IO2 _PINNUM(1, 9)
|
||||
#define PIN_QSPI_IO3 _PINNUM(0, 26)
|
||||
|
||||
#define EXTERNAL_FLASH_DEVICES ZD25WQ32CEIGR
|
||||
#define EXTERNAL_FLASH_USE_QSPI
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Builtin LEDs
|
||||
|
||||
@@ -95,9 +92,6 @@
|
||||
#define PIN_BUTTON2 _PINNUM(0, 18)
|
||||
#define BUTTON_PIN2 PIN_BUTTON2
|
||||
|
||||
#define EXTERNAL_FLASH_DEVICES MX25R1635F
|
||||
#define EXTERNAL_FLASH_USE_QSPI
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Lora
|
||||
|
||||
@@ -154,8 +148,8 @@ extern const int SCK;
|
||||
// GPS — per LilyGo t_echo_lite_config.h
|
||||
// PIN_GPS_TX/RX named from GPS module's perspective
|
||||
|
||||
#define PIN_GPS_TX _PINNUM(0, 29) // GPS UART TX → MCU RX
|
||||
#define PIN_GPS_RX _PINNUM(1, 10) // GPS UART RX ← MCU TX
|
||||
#define PIN_GPS_RX _PINNUM(0, 29) // GPS UART TX → MCU RX
|
||||
#define PIN_GPS_TX _PINNUM(1, 10) // GPS UART RX ← MCU TX
|
||||
#define GPS_EN _PINNUM(1, 11) // GPS RT9080 power enable
|
||||
#define PIN_GPS_STANDBY _PINNUM(1, 13) // GPS wake-up
|
||||
#define PIN_GPS_PPS _PINNUM(1, 15) // GPS 1PPS
|
||||
#define PIN_GPS_PPS _PINNUM(1, 15) // GPS 1PPS
|
||||
@@ -110,5 +110,9 @@ lib_deps =
|
||||
|
||||
[env:M5Stack_Unit_C6L_kiss_modem]
|
||||
extends = M5Stack_Unit_C6L
|
||||
build_flags = ${M5Stack_Unit_C6L.build_flags}
|
||||
-D ARDUINO_USB_CDC_ON_BOOT=1
|
||||
-D ARDUINO_USB_MODE=1
|
||||
-D ENABLE_USB_INTERFACE
|
||||
build_src_filter = ${M5Stack_Unit_C6L.build_src_filter}
|
||||
+<../examples/kiss_modem/>
|
||||
@@ -9,7 +9,7 @@ protected:
|
||||
uint8_t btn_prev_state;
|
||||
|
||||
public:
|
||||
MeshtinyBoard() : NRF52Board("Meshtiny OTA") {}
|
||||
MeshtinyBoard() : NRF52Board("Meshtiny_OTA") {}
|
||||
void begin();
|
||||
|
||||
#if defined(P_LORA_TX_LED)
|
||||
|
||||
@@ -5,7 +5,6 @@
|
||||
|
||||
void MeshTrackerX1Board::begin() {
|
||||
NRF52BoardDCDC::begin();
|
||||
btn_prev_state = LOW; // button is active HIGH
|
||||
|
||||
#ifdef BUTTON_PIN
|
||||
pinMode(BATTERY_PIN, INPUT);
|
||||
|
||||
@@ -5,9 +5,6 @@
|
||||
#include <helpers/NRF52Board.h>
|
||||
|
||||
class MeshTrackerX1Board : public NRF52BoardDCDC {
|
||||
protected:
|
||||
uint8_t btn_prev_state;
|
||||
|
||||
public:
|
||||
MeshTrackerX1Board() : NRF52Board("X1_OTA") {}
|
||||
void begin();
|
||||
@@ -35,17 +32,6 @@ public:
|
||||
return "Seeed SenseCAP MeshTracker X1";
|
||||
}
|
||||
|
||||
int buttonStateChanged() {
|
||||
#ifdef BUTTON_PIN
|
||||
uint8_t v = digitalRead(BUTTON_PIN);
|
||||
if (v != btn_prev_state) {
|
||||
btn_prev_state = v;
|
||||
return (v == USER_BTN_PRESSED) ? 1 : -1;
|
||||
}
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
void powerOff() override {
|
||||
#ifdef HAS_GPS
|
||||
digitalWrite(GPS_VRTC_EN, LOW);
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
#include <Arduino.h>
|
||||
#include "target.h"
|
||||
#include <helpers/sensors/MicroNMEALocationProvider.h>
|
||||
#include <helpers/sensors/AirohaSleep.h>
|
||||
|
||||
MeshTrackerX1Board board;
|
||||
|
||||
@@ -27,46 +28,27 @@ mesh::LocalIdentity radio_new_identity() {
|
||||
|
||||
void MeshTrackerX1SensorManager::start_gps() {
|
||||
gps_active = true;
|
||||
// this init sequence comes from seeed examples and deals with all gps pins
|
||||
pinMode(GPS_EN, OUTPUT);
|
||||
digitalWrite(GPS_EN, HIGH);
|
||||
delay(10);
|
||||
pinMode(GPS_VRTC_EN, OUTPUT);
|
||||
digitalWrite(GPS_VRTC_EN, HIGH);
|
||||
delay(10);
|
||||
|
||||
pinMode(GPS_RESET, OUTPUT);
|
||||
digitalWrite(GPS_RESET, HIGH);
|
||||
delay(10);
|
||||
digitalWrite(GPS_RESET, LOW);
|
||||
|
||||
pinMode(GPS_SLEEP_INT, OUTPUT);
|
||||
digitalWrite(GPS_SLEEP_INT, HIGH);
|
||||
pinMode(GPS_RTC_INT, OUTPUT);
|
||||
digitalWrite(GPS_RTC_INT, LOW);
|
||||
}
|
||||
|
||||
void MeshTrackerX1SensorManager::sleep_gps() {
|
||||
gps_active = false;
|
||||
digitalWrite(GPS_VRTC_EN, HIGH); // keep RTC alive for faster fix on wake
|
||||
digitalWrite(GPS_EN, LOW);
|
||||
digitalWrite(GPS_RESET, LOW);
|
||||
digitalWrite(GPS_SLEEP_INT, HIGH);
|
||||
digitalWrite(GPS_RTC_INT, HIGH);
|
||||
delay(5);
|
||||
digitalWrite(GPS_RTC_INT, LOW);
|
||||
}
|
||||
|
||||
void MeshTrackerX1SensorManager::stop_gps() {
|
||||
gps_active = false;
|
||||
digitalWrite(GPS_VRTC_EN, LOW);
|
||||
digitalWrite(GPS_VRTC_EN, HIGH); // keep GPS RTC alive for faster fix on wake
|
||||
digitalWrite(GPS_RTC_INT, LOW); // make sure this is LOW so we can pulse it to wake
|
||||
airohaEnterSleep(_nmea);
|
||||
digitalWrite(GPS_EN, LOW);
|
||||
digitalWrite(GPS_RESET, LOW);
|
||||
digitalWrite(GPS_SLEEP_INT, HIGH);
|
||||
digitalWrite(GPS_RTC_INT, LOW);
|
||||
}
|
||||
|
||||
bool MeshTrackerX1SensorManager::begin() {
|
||||
// init GPS
|
||||
Serial1.begin(GPS_BAUD_RATE);
|
||||
digitalWrite(GPS_RESET, HIGH);
|
||||
delay(10);
|
||||
digitalWrite(GPS_RESET, LOW);
|
||||
|
||||
// init SPA06-003 barometer
|
||||
baro_ok = spa06.begin(SPA06_003_DEFAULT_ADDR, &Wire) || spa06.begin(0x76, &Wire);
|
||||
@@ -122,7 +104,7 @@ const char* MeshTrackerX1SensorManager::getSettingValue(int i) const {
|
||||
bool MeshTrackerX1SensorManager::setSettingValue(const char* name, const char* value) {
|
||||
if (strcmp(name, "gps") == 0) {
|
||||
if (strcmp(value, "0") == 0) {
|
||||
sleep_gps(); // sleep for faster fix !
|
||||
stop_gps();
|
||||
} else {
|
||||
start_gps();
|
||||
}
|
||||
|
||||
@@ -7,7 +7,6 @@ build_flags = ${nrf52_base.build_flags}
|
||||
-I variants/muziworks_r1_neo
|
||||
-I src/helpers/ui
|
||||
-D R1Neo
|
||||
-D NRF52_POWER_MANAGEMENT
|
||||
-D RADIO_CLASS=CustomSX1262
|
||||
-D WRAPPER_CLASS=CustomSX1262Wrapper
|
||||
-D DISPLAY_CLASS=NullDisplayDriver
|
||||
|
||||
@@ -5,7 +5,6 @@
|
||||
|
||||
void PromicroBoard::begin() {
|
||||
NRF52Board::begin();
|
||||
btn_prev_state = HIGH;
|
||||
|
||||
pinMode(PIN_VBAT_READ, INPUT);
|
||||
|
||||
|
||||
@@ -9,7 +9,6 @@
|
||||
|
||||
class PromicroBoard : public NRF52BoardDCDC {
|
||||
protected:
|
||||
uint8_t btn_prev_state;
|
||||
float adc_mult = ADC_MULTIPLIER;
|
||||
|
||||
public:
|
||||
@@ -48,15 +47,4 @@ public:
|
||||
const char* getManufacturerName() const override {
|
||||
return "ProMicro DIY";
|
||||
}
|
||||
|
||||
int buttonStateChanged() {
|
||||
#ifdef BUTTON_PIN
|
||||
uint8_t v = digitalRead(BUTTON_PIN);
|
||||
if (v != btn_prev_state) {
|
||||
btn_prev_state = v;
|
||||
return (v == LOW) ? 1 : -1;
|
||||
}
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
@@ -23,6 +23,7 @@ build_flags = ${nrf52_base.build_flags}
|
||||
-D ENV_INCLUDE_BMP280=1
|
||||
-D ENV_INCLUDE_INA3221=1
|
||||
-D ENV_INCLUDE_INA219=1
|
||||
-D ENV_INCLUDE_INA226=1
|
||||
build_src_filter = ${nrf52_base.build_src_filter}
|
||||
+<helpers/sensors>
|
||||
+<../variants/promicro>
|
||||
@@ -34,6 +35,7 @@ lib_deps= ${nrf52_base.lib_deps}
|
||||
adafruit/Adafruit BME280 Library @ ^2.3.0
|
||||
adafruit/Adafruit BMP280 Library@^2.6.8
|
||||
stevemarple/MicroNMEA @ ^2.0.6
|
||||
robtillaart/INA226@^0.6.6
|
||||
|
||||
[env:ProMicro_repeater]
|
||||
extends = Promicro
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
|
||||
#include <Arduino.h>
|
||||
#include <MeshCore.h>
|
||||
#include <helpers/KeyValueStore.h>
|
||||
|
||||
// from https://github.com/RAKWireless/RAK11300-AT-Command-Firmware/blob/9c48409a43620a828d653501d536473200aa33af/RAK11300-AT-Arduino/batt.cpp#L17-L19
|
||||
#define VBAT_MV_PER_LSB (0.806F) // 3.0V ADC range and 12 - bit ADC resolution = 3300mV / 4096
|
||||
@@ -46,4 +47,6 @@ public:
|
||||
void reboot() override { rp2040.reboot(); }
|
||||
|
||||
bool startOTAUpdate(const char *id, char reply[]) override;
|
||||
|
||||
void attachDynamicPrefs(KeyValueStore* prefs) { } // no-op
|
||||
};
|
||||
@@ -155,12 +155,14 @@ build_flags =
|
||||
-D MAX_GROUP_CHANNELS=40
|
||||
-D BLE_PIN_CODE=123456 ; dynamic, random PIN
|
||||
-D AUTO_SHUTDOWN_MILLIVOLTS=3400
|
||||
-D BLE_DEBUG_LOGGING=1
|
||||
-D OFFLINE_QUEUE_SIZE=256
|
||||
-D ENABLE_WIFI_INTERFACE
|
||||
; -D BLE_DEBUG_LOGGING=1
|
||||
; -D MESH_PACKET_LOGGING=1
|
||||
; -D MESH_DEBUG=1
|
||||
build_src_filter = ${rak3112.build_src_filter}
|
||||
+<helpers/esp32/*.cpp>
|
||||
+<helpers/wifi/*.cpp>
|
||||
+<../examples/companion_radio/*.cpp>
|
||||
+<../examples/companion_radio/ui-orig/*.cpp>
|
||||
lib_deps =
|
||||
|
||||
@@ -7,7 +7,6 @@ build_flags = ${nrf52_base.build_flags}
|
||||
-I variants/rak3401
|
||||
-D RAK_3401
|
||||
-D RAK_BOARD
|
||||
-D NRF52_POWER_MANAGEMENT
|
||||
-D RADIO_CLASS=CustomSX1262
|
||||
-D WRAPPER_CLASS=CustomSX1262Wrapper
|
||||
-D LORA_TX_POWER=22
|
||||
|
||||
@@ -9,7 +9,6 @@ build_flags = ${nrf52_base.build_flags}
|
||||
-I variants/rak4631
|
||||
-D RAK_4631
|
||||
-D RAK_BOARD
|
||||
-D NRF52_POWER_MANAGEMENT
|
||||
-D PIN_BOARD_SCL=14
|
||||
-D PIN_BOARD_SDA=13
|
||||
-D PIN_GPS_TX=PIN_SERIAL1_RX
|
||||
@@ -29,11 +28,14 @@ build_src_filter = ${nrf52_base.build_src_filter}
|
||||
+<../variants/rak4631>
|
||||
+<helpers/sensors>
|
||||
+<helpers/ui/SSD1306Display.cpp>
|
||||
+<helpers/ui/SH1106Display.cpp>
|
||||
+<helpers/ui/AutoDetectDisplay.cpp>
|
||||
+<helpers/ui/MomentaryButton.cpp>
|
||||
lib_deps =
|
||||
${nrf52_base.lib_deps}
|
||||
${sensor_base.lib_deps}
|
||||
adafruit/Adafruit SSD1306 @ ^2.5.13
|
||||
adafruit/Adafruit SH110X @ ^2.1.13
|
||||
sparkfun/SparkFun u-blox GNSS Arduino Library@^2.2.27
|
||||
boschsensortec/BSEC Software Library @ ^1.8.1492
|
||||
|
||||
@@ -41,7 +43,7 @@ lib_deps =
|
||||
extends = rak4631
|
||||
build_flags =
|
||||
${rak4631.build_flags}
|
||||
-D DISPLAY_CLASS=SSD1306Display
|
||||
-D DISPLAY_CLASS=AutoDetectDisplay
|
||||
-D ADVERT_NAME='"RAK4631 Repeater"'
|
||||
-D ADVERT_LAT=0.0
|
||||
-D ADVERT_LON=0.0
|
||||
@@ -57,7 +59,7 @@ build_src_filter = ${rak4631.build_src_filter}
|
||||
extends = rak4631
|
||||
build_flags =
|
||||
${rak4631.build_flags}
|
||||
-D DISPLAY_CLASS=SSD1306Display
|
||||
-D DISPLAY_CLASS=AutoDetectDisplay
|
||||
-D ADVERT_NAME='"RAK4631 Repeater"'
|
||||
-D ADVERT_LAT=0.0
|
||||
-D ADVERT_LON=0.0
|
||||
@@ -76,7 +78,7 @@ lib_deps =
|
||||
extends = rak4631
|
||||
build_flags =
|
||||
${rak4631.build_flags}
|
||||
-D DISPLAY_CLASS=SSD1306Display
|
||||
-D DISPLAY_CLASS=AutoDetectDisplay
|
||||
-D ADVERT_NAME='"RS232 Bridge"'
|
||||
-D ADVERT_LAT=0.0
|
||||
-D ADVERT_LON=0.0
|
||||
@@ -99,7 +101,7 @@ build_src_filter = ${rak4631.build_src_filter}
|
||||
extends = rak4631
|
||||
build_flags =
|
||||
${rak4631.build_flags}
|
||||
-D DISPLAY_CLASS=SSD1306Display
|
||||
-D DISPLAY_CLASS=AutoDetectDisplay
|
||||
-D ADVERT_NAME='"RS232 Bridge"'
|
||||
-D ADVERT_LAT=0.0
|
||||
-D ADVERT_LON=0.0
|
||||
@@ -122,7 +124,7 @@ build_src_filter = ${rak4631.build_src_filter}
|
||||
extends = rak4631
|
||||
build_flags =
|
||||
${rak4631.build_flags}
|
||||
-D DISPLAY_CLASS=SSD1306Display
|
||||
-D DISPLAY_CLASS=AutoDetectDisplay
|
||||
-D ADVERT_NAME='"Test Room"'
|
||||
-D ADVERT_LAT=0.0
|
||||
-D ADVERT_LON=0.0
|
||||
@@ -138,7 +140,7 @@ build_src_filter = ${rak4631.build_src_filter}
|
||||
extends = rak4631
|
||||
build_flags =
|
||||
${rak4631.build_flags}
|
||||
-D DISPLAY_CLASS=SSD1306Display
|
||||
-D DISPLAY_CLASS=AutoDetectDisplay
|
||||
-D ADVERT_NAME='"RAK4631 Room Server"'
|
||||
-D ADVERT_LAT=0.0
|
||||
-D ADVERT_LON=0.0
|
||||
@@ -162,7 +164,7 @@ build_flags =
|
||||
-I examples/companion_radio/ui-new
|
||||
-D PIN_USER_BTN=9
|
||||
-D PIN_USER_BTN_ANA=31
|
||||
-D DISPLAY_CLASS=SSD1306Display
|
||||
-D DISPLAY_CLASS=AutoDetectDisplay
|
||||
-D MAX_CONTACTS=350
|
||||
-D MAX_GROUP_CHANNELS=40
|
||||
-D ENABLE_USB_INTERFACE
|
||||
@@ -187,7 +189,7 @@ build_flags =
|
||||
-I examples/companion_radio/ui-new
|
||||
-D PIN_USER_BTN=9
|
||||
-D PIN_USER_BTN_ANA=31
|
||||
-D DISPLAY_CLASS=SSD1306Display
|
||||
-D DISPLAY_CLASS=AutoDetectDisplay
|
||||
-D MAX_CONTACTS=350
|
||||
-D MAX_GROUP_CHANNELS=40
|
||||
-D ETHERNET_ENABLED=1
|
||||
@@ -216,7 +218,7 @@ build_flags =
|
||||
-I examples/companion_radio/ui-new
|
||||
-D PIN_USER_BTN=9
|
||||
-D PIN_USER_BTN_ANA=31
|
||||
-D DISPLAY_CLASS=SSD1306Display
|
||||
-D DISPLAY_CLASS=AutoDetectDisplay
|
||||
-D MAX_CONTACTS=350
|
||||
-D MAX_GROUP_CHANNELS=40
|
||||
-D BLE_PIN_CODE=123456
|
||||
@@ -252,7 +254,7 @@ lib_deps =
|
||||
extends = rak4631
|
||||
build_flags =
|
||||
${rak4631.build_flags}
|
||||
-D DISPLAY_CLASS=SSD1306Display
|
||||
-D DISPLAY_CLASS=AutoDetectDisplay
|
||||
-D ADVERT_NAME='"RAK4631 Sensor"'
|
||||
-D ADVERT_LAT=0.0
|
||||
-D ADVERT_LON=0.0
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
#include <helpers/sensors/EnvironmentSensorManager.h>
|
||||
|
||||
#ifdef DISPLAY_CLASS
|
||||
#include <helpers/ui/SSD1306Display.h>
|
||||
#include <helpers/ui/AutoDetectDisplay.h>
|
||||
extern DISPLAY_CLASS display;
|
||||
#include <helpers/ui/MomentaryButton.h>
|
||||
extern MomentaryButton user_btn;
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
#include <Arduino.h>
|
||||
#include <Wire.h>
|
||||
#include <HardwarePWM.h>
|
||||
|
||||
#include "SenseCapSolarBoard.h"
|
||||
|
||||
@@ -50,6 +51,9 @@ void SenseCapSolarBoard::begin() {
|
||||
#ifdef LED_WHITE
|
||||
pinMode(LED_WHITE, OUTPUT);
|
||||
digitalWrite(LED_WHITE, LOW);
|
||||
#ifdef SENSECAP_SOLAR_WHITE_LED
|
||||
white_led_last_pulse_at_ = millis(); // first heartbeat pulse 5 s after boot
|
||||
#endif
|
||||
#endif
|
||||
#ifdef LED_BLUE
|
||||
pinMode(LED_BLUE, OUTPUT);
|
||||
@@ -67,3 +71,76 @@ void SenseCapSolarBoard::begin() {
|
||||
|
||||
delay(10); // give sx1262 some time to power up
|
||||
}
|
||||
|
||||
#ifdef SENSECAP_SOLAR_WHITE_LED
|
||||
// Dimmed WHITE heartbeat using hardware PWM (repeater builds only).
|
||||
//
|
||||
// Peripheral audit for this firmware: no analogWrite()/tone() callers, no
|
||||
// NeoPixel/Servo, Bluefruit52Lib uses no PWM, SoftDevice S140 does not own
|
||||
// any PWM instance -> NRF_PWM0 (HwPWM0) is free. takeOwnership() fences the
|
||||
// instance so a future analogWrite() caller cannot claim it.
|
||||
//
|
||||
// Timing: base clock 16 MHz (DIV_1), COUNTERTOP 16000 -> exactly 1 kHz.
|
||||
// Duty: HardwarePWM non-inverted values place bit15 (active-HIGH polarity),
|
||||
// so compare 1600 => HIGH for [0,1600)/16000 => 10% duty, active-high.
|
||||
static const uint32_t WHITE_LED_PWM_TOKEN = 0x5031574C; // 'P1WL'
|
||||
static const uint16_t WHITE_LED_PWM_TOP = 16000; // 16 MHz / 16000 = 1 kHz
|
||||
static const uint16_t WHITE_LED_PWM_DUTY = 1600; // 1600 / 16000 = 10 %
|
||||
static_assert(WHITE_LED_PWM_TOP <= 0x7FFF, "PWM compare values are 15-bit");
|
||||
static_assert(WHITE_LED_PWM_DUTY < WHITE_LED_PWM_TOP, "duty must stay below COUNTERTOP");
|
||||
|
||||
void SenseCapSolarBoard::whiteLedHeartbeatOn() {
|
||||
HwPWM0.takeOwnership(WHITE_LED_PWM_TOKEN); // no-op once owned; keeps analogWrite away
|
||||
HwPWM0.setClockDiv(PWM_PRESCALER_PRESCALER_DIV_1); // 16 MHz base clock
|
||||
HwPWM0.setMaxValue(WHITE_LED_PWM_TOP); // 1 kHz period
|
||||
HwPWM0.addPin(LED_WHITE); // drives pin LOW, connects PSEL
|
||||
HwPWM0.writePin(LED_WHITE, WHITE_LED_PWM_DUTY); // enables + starts 10% PWM
|
||||
}
|
||||
|
||||
void SenseCapSolarBoard::whiteLedHeartbeatOff() {
|
||||
HwPWM0.stop(); // ENABLE=0: waveform and its HFCLK demand stop
|
||||
if (HwPWM0.checkPin(LED_WHITE)) {
|
||||
HwPWM0.removePin(LED_WHITE); // disconnect PSEL; GPIO block drives again
|
||||
}
|
||||
pinMode(LED_WHITE, OUTPUT);
|
||||
digitalWrite(LED_WHITE, LOW); // deterministic LOW during the 4900 ms off phase
|
||||
}
|
||||
|
||||
// 100 ms pulse every 5000 ms, non-blocking millis() with wrap-safe unsigned
|
||||
// arithmetic. Called from loop(); frozen while the OTA steady-on owns the LED.
|
||||
void SenseCapSolarBoard::updateWhiteStatusLed() {
|
||||
if (white_led_ota_active_) return;
|
||||
|
||||
const uint32_t now = millis();
|
||||
const uint32_t elapsed = (uint32_t)(now - white_led_last_pulse_at_);
|
||||
if (white_led_pulse_active_ && elapsed >= 100U) {
|
||||
whiteLedHeartbeatOff(); // stop PWM, pin LOW
|
||||
white_led_pulse_active_ = false;
|
||||
}
|
||||
if (!white_led_pulse_active_ && elapsed >= 5000U) {
|
||||
whiteLedHeartbeatOn(); // 1 kHz hardware PWM, 10% duty
|
||||
white_led_pulse_active_ = true;
|
||||
white_led_last_pulse_at_ = now;
|
||||
}
|
||||
}
|
||||
|
||||
void SenseCapSolarBoard::loop() {
|
||||
mesh::MainBoard::loop(); // keep base housekeeping (watchdog etc.) if it ever gains any
|
||||
updateWhiteStatusLed();
|
||||
}
|
||||
|
||||
// `start ota` keeps WHITE on for as long as the application is advertising
|
||||
// its BLE OTA service. The heartbeat PWM is stopped and the pin released
|
||||
// first, so steady-on is a plain full-brightness GPIO drive (no PWM vs
|
||||
// digitalWrite conflict). On a failed start nothing changes: the heartbeat
|
||||
// keeps its normal blinking.
|
||||
bool SenseCapSolarBoard::startOTAUpdate(const char *id, char reply[]) {
|
||||
const bool started = NRF52Board::startOTAUpdate(id, reply);
|
||||
if (started) {
|
||||
white_led_ota_active_ = true;
|
||||
whiteLedHeartbeatOff();
|
||||
digitalWrite(LED_WHITE, LED_STATE_ON);
|
||||
}
|
||||
return started;
|
||||
}
|
||||
#endif // SENSECAP_SOLAR_WHITE_LED
|
||||
@@ -5,6 +5,19 @@
|
||||
#include <helpers/NRF52Board.h>
|
||||
|
||||
class SenseCapSolarBoard : public NRF52BoardDCDC {
|
||||
#ifdef SENSECAP_SOLAR_WHITE_LED
|
||||
// Dimmed white-LED heartbeat state (repeater builds only; enabled with
|
||||
// -D SENSECAP_SOLAR_WHITE_LED in the PlatformIO env, so room-server and
|
||||
// companion firmwares sharing this board class are unaffected).
|
||||
bool white_led_ota_active_ = false;
|
||||
bool white_led_pulse_active_ = false;
|
||||
uint32_t white_led_last_pulse_at_ = 0;
|
||||
|
||||
void whiteLedHeartbeatOn(); // start 1 kHz PWM at 10% duty on LED_WHITE
|
||||
void whiteLedHeartbeatOff(); // stop/release PWM, hold LED_WHITE LOW
|
||||
void updateWhiteStatusLed(); // non-blocking 100 ms pulse every 5000 ms
|
||||
#endif
|
||||
|
||||
protected:
|
||||
#ifdef NRF52_POWER_MANAGEMENT
|
||||
void initiateShutdown(uint8_t reason) override;
|
||||
@@ -14,6 +27,13 @@ public:
|
||||
SenseCapSolarBoard() : NRF52Board("SENSECAP_SOLAR_OTA") {}
|
||||
void begin();
|
||||
|
||||
#ifdef SENSECAP_SOLAR_WHITE_LED
|
||||
// Runs the white-LED heartbeat; invoked by the example main loops via the
|
||||
// existing board.loop() call (mesh::MainBoard::loop() is a no-op by default).
|
||||
void loop() override;
|
||||
bool startOTAUpdate(const char *id, char reply[]) override;
|
||||
#endif
|
||||
|
||||
#if defined(P_LORA_TX_LED)
|
||||
void onBeforeTransmit() override {
|
||||
digitalWrite(P_LORA_TX_LED, HIGH); // turn TX LED on
|
||||
@@ -38,6 +58,9 @@ public:
|
||||
}
|
||||
|
||||
void powerOff() override {
|
||||
#ifdef SENSECAP_SOLAR_WHITE_LED
|
||||
whiteLedHeartbeatOff(); // stop/release the heartbeat PWM before shutdown
|
||||
#endif
|
||||
digitalWrite(LED_WHITE, LOW);
|
||||
digitalWrite(LED_BLUE, LOW);
|
||||
|
||||
|
||||
@@ -10,7 +10,6 @@ build_flags = ${nrf52_base.build_flags}
|
||||
-I src/helpers/nrf52
|
||||
-D NRF52_PLATFORM=1
|
||||
-D USE_SX1262
|
||||
-D NRF52_POWER_MANAGEMENT
|
||||
-D RADIO_CLASS=CustomSX1262
|
||||
-D WRAPPER_CLASS=CustomSX1262Wrapper
|
||||
-D P_LORA_TX_LED=12
|
||||
@@ -46,6 +45,8 @@ build_flags =
|
||||
-D ADVERT_LON=0.0
|
||||
-D ADMIN_PASSWORD='"password"'
|
||||
-D MAX_NEIGHBOURS=50
|
||||
; dimmed white-LED heartbeat + OTA steady-on (repeater builds only)
|
||||
-D SENSECAP_SOLAR_WHITE_LED=1
|
||||
; -D MESH_PACKET_LOGGING=1
|
||||
; -D MESH_DEBUG=1
|
||||
build_src_filter = ${SenseCap_Solar.build_src_filter}
|
||||
|
||||
@@ -5,7 +5,6 @@
|
||||
|
||||
void T1000eBoard::begin() {
|
||||
NRF52BoardDCDC::begin();
|
||||
btn_prev_state = HIGH;
|
||||
|
||||
#ifdef BUTTON_PIN
|
||||
pinMode(BATTERY_PIN, INPUT);
|
||||
|
||||
@@ -5,9 +5,6 @@
|
||||
#include <helpers/NRF52Board.h>
|
||||
|
||||
class T1000eBoard : public NRF52BoardDCDC {
|
||||
protected:
|
||||
uint8_t btn_prev_state;
|
||||
|
||||
public:
|
||||
T1000eBoard() : NRF52Board("T1000E_OTA") {}
|
||||
void begin();
|
||||
@@ -38,17 +35,6 @@ public:
|
||||
return "Seeed Tracker T1000-E";
|
||||
}
|
||||
|
||||
int buttonStateChanged() {
|
||||
#ifdef BUTTON_PIN
|
||||
uint8_t v = digitalRead(BUTTON_PIN);
|
||||
if (v != btn_prev_state) {
|
||||
btn_prev_state = v;
|
||||
return (v == USER_BTN_PRESSED) ? 1 : -1;
|
||||
}
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
void powerOff() override {
|
||||
#ifdef HAS_GPS
|
||||
digitalWrite(GPS_VRTC_EN, LOW);
|
||||
@@ -69,10 +55,6 @@ public:
|
||||
#ifdef PIN_3V3_ACC_EN
|
||||
digitalWrite(PIN_3V3_ACC_EN, LOW);
|
||||
#endif
|
||||
#ifdef SENSOR_EN
|
||||
digitalWrite(SENSOR_EN, LOW);
|
||||
#endif
|
||||
|
||||
// set led on and wait for button release before poweroff
|
||||
#ifdef LED_PIN
|
||||
digitalWrite(LED_PIN, HIGH);
|
||||
|
||||
@@ -72,7 +72,6 @@ float t1000e_get_temperature(void) {
|
||||
unsigned int ntc_v, vcc_v;
|
||||
|
||||
digitalWrite(PIN_3V3_EN, HIGH);
|
||||
digitalWrite(SENSOR_EN, HIGH);
|
||||
analogReference(AR_INTERNAL_3_0);
|
||||
analogReadResolution(12);
|
||||
delay(10);
|
||||
@@ -80,7 +79,6 @@ float t1000e_get_temperature(void) {
|
||||
vcc_v = (rail_v > NTC_REF_VCC) ? NTC_REF_VCC : rail_v;
|
||||
ntc_v = (1000.0 * AREF_VOLTAGE * analogRead(TEMP_SENSOR)) / 4096;
|
||||
digitalWrite(PIN_3V3_EN, LOW);
|
||||
digitalWrite(SENSOR_EN, LOW);
|
||||
|
||||
return get_heater_temperature(vcc_v, ntc_v);
|
||||
}
|
||||
@@ -90,13 +88,11 @@ uint32_t t1000e_get_light(void) {
|
||||
unsigned int lux_v = 0;
|
||||
|
||||
digitalWrite(PIN_3V3_EN, HIGH);
|
||||
digitalWrite(SENSOR_EN, HIGH);
|
||||
analogReference(AR_INTERNAL_3_0);
|
||||
analogReadResolution(12);
|
||||
delay(10);
|
||||
lux_v = 1000 * analogRead(LUX_SENSOR) * AREF_VOLTAGE / 4096;
|
||||
lux = get_light_lv(lux_v);
|
||||
digitalWrite(SENSOR_EN, LOW);
|
||||
digitalWrite(PIN_3V3_EN, LOW);
|
||||
|
||||
return lux;
|
||||
|
||||
+10
-38
@@ -2,6 +2,7 @@
|
||||
#include "t1000e_sensors.h"
|
||||
#include "target.h"
|
||||
#include <helpers/sensors/MicroNMEALocationProvider.h>
|
||||
#include <helpers/sensors/AirohaSleep.h>
|
||||
|
||||
T1000eBoard board;
|
||||
|
||||
@@ -81,56 +82,28 @@ mesh::LocalIdentity radio_new_identity() {
|
||||
|
||||
void T1000SensorManager::start_gps() {
|
||||
gps_active = true;
|
||||
//_nmea->begin();
|
||||
// this init sequence should be better
|
||||
// comes from seeed examples and deals with all gps pins
|
||||
pinMode(GPS_EN, OUTPUT);
|
||||
digitalWrite(GPS_EN, HIGH);
|
||||
delay(10);
|
||||
pinMode(GPS_VRTC_EN, OUTPUT);
|
||||
digitalWrite(GPS_VRTC_EN, HIGH);
|
||||
delay(10);
|
||||
|
||||
pinMode(GPS_RESET, OUTPUT);
|
||||
digitalWrite(GPS_RESET, HIGH);
|
||||
delay(10);
|
||||
digitalWrite(GPS_RESET, LOW);
|
||||
|
||||
pinMode(GPS_SLEEP_INT, OUTPUT);
|
||||
digitalWrite(GPS_SLEEP_INT, HIGH);
|
||||
pinMode(GPS_RTC_INT, OUTPUT);
|
||||
digitalWrite(GPS_RTC_INT, HIGH);
|
||||
delay(5);
|
||||
digitalWrite(GPS_RTC_INT, LOW);
|
||||
pinMode(GPS_RESETB, INPUT_PULLUP);
|
||||
}
|
||||
|
||||
void T1000SensorManager::sleep_gps() {
|
||||
gps_active = false;
|
||||
digitalWrite(GPS_VRTC_EN, HIGH);
|
||||
digitalWrite(GPS_EN, LOW);
|
||||
digitalWrite(GPS_RESET, HIGH);
|
||||
digitalWrite(GPS_SLEEP_INT, HIGH);
|
||||
digitalWrite(GPS_RTC_INT, LOW);
|
||||
pinMode(GPS_RESETB, OUTPUT);
|
||||
digitalWrite(GPS_RESETB, LOW);
|
||||
//_nmea->stop();
|
||||
}
|
||||
|
||||
void T1000SensorManager::stop_gps() {
|
||||
gps_active = false;
|
||||
digitalWrite(GPS_VRTC_EN, LOW);
|
||||
digitalWrite(GPS_VRTC_EN, HIGH); // keep GPS RTC alive for faster fix on wake
|
||||
digitalWrite(GPS_RTC_INT, LOW); // make sure this is LOW so we can pulse it to wake
|
||||
airohaEnterSleep(_nmea); // send command to put the GPS into RTC backup sleep
|
||||
digitalWrite(GPS_EN, LOW);
|
||||
digitalWrite(GPS_RESET, HIGH);
|
||||
digitalWrite(GPS_SLEEP_INT, HIGH);
|
||||
digitalWrite(GPS_RTC_INT, LOW);
|
||||
pinMode(GPS_RESETB, OUTPUT);
|
||||
digitalWrite(GPS_RESETB, LOW);
|
||||
//_nmea->stop();
|
||||
}
|
||||
|
||||
|
||||
bool T1000SensorManager::begin() {
|
||||
// init GPS
|
||||
Serial1.begin(115200);
|
||||
digitalWrite(GPS_RESET, HIGH);
|
||||
delay(10);
|
||||
digitalWrite(GPS_RESET, LOW);
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -156,7 +129,6 @@ void T1000SensorManager::loop() {
|
||||
node_lat = ((double)_nmea->getLatitude())/1000000.;
|
||||
node_lon = ((double)_nmea->getLongitude())/1000000.;
|
||||
node_altitude = ((double)_nmea->getAltitude()) / 1000.0;
|
||||
//Serial.printf("lat %f lon %f\r\n", _lat, _lon);
|
||||
}
|
||||
next_gps_update = millis() + 1000;
|
||||
}
|
||||
@@ -176,7 +148,7 @@ const char* T1000SensorManager::getSettingValue(int i) const {
|
||||
bool T1000SensorManager::setSettingValue(const char* name, const char* value) {
|
||||
if (strcmp(name, "gps") == 0) {
|
||||
if (strcmp(value, "0") == 0) {
|
||||
sleep_gps(); // sleep for faster fix !
|
||||
stop_gps();
|
||||
} else {
|
||||
start_gps();
|
||||
}
|
||||
|
||||
@@ -14,7 +14,7 @@ const uint32_t g_ADigitalPinMap[PINS_COUNT + 1] =
|
||||
1, // P0.01
|
||||
2, // P0.02, AIN0 BATTERY_PIN
|
||||
3, // P0.03
|
||||
4, // P0.04, SENSOR_EN
|
||||
4, // P0.04
|
||||
5, // P0.05, EXT_PWR_DETEC
|
||||
6, // P0.06, PIN_BUTTON1
|
||||
7, // P0.07, LORA_BUSY
|
||||
@@ -71,13 +71,12 @@ void initVariant()
|
||||
pinMode(LUX_SENSOR, INPUT);
|
||||
pinMode(EXT_CHRG_DETECT, INPUT);
|
||||
pinMode(EXT_PWR_DETECT, INPUT);
|
||||
pinMode(GPS_RESETB, INPUT);
|
||||
pinMode(GPS_RESETB, INPUT_PULLUP);
|
||||
pinMode(PIN_BUTTON1, INPUT);
|
||||
|
||||
pinMode(PIN_3V3_EN, OUTPUT);
|
||||
pinMode(PIN_3V3_ACC_EN, OUTPUT);
|
||||
pinMode(BUZZER_EN, OUTPUT);
|
||||
pinMode(SENSOR_EN, OUTPUT);
|
||||
pinMode(GPS_EN, OUTPUT);
|
||||
pinMode(GPS_RESET, OUTPUT);
|
||||
pinMode(GPS_VRTC_EN, OUTPUT);
|
||||
@@ -88,11 +87,10 @@ void initVariant()
|
||||
digitalWrite(PIN_3V3_EN, LOW);
|
||||
digitalWrite(PIN_3V3_ACC_EN, LOW);
|
||||
digitalWrite(BUZZER_EN, LOW);
|
||||
digitalWrite(SENSOR_EN, LOW);
|
||||
digitalWrite(GPS_EN, LOW);
|
||||
digitalWrite(GPS_RESET, LOW);
|
||||
digitalWrite(GPS_VRTC_EN, LOW);
|
||||
digitalWrite(GPS_SLEEP_INT, HIGH);
|
||||
digitalWrite(GPS_VRTC_EN, HIGH);
|
||||
digitalWrite(GPS_SLEEP_INT, LOW);
|
||||
digitalWrite(GPS_RTC_INT, LOW);
|
||||
digitalWrite(LED_PIN, LOW);
|
||||
}
|
||||
@@ -120,7 +120,6 @@
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Temp+Lux Sensor
|
||||
|
||||
#define SENSOR_EN (4) // P0.4
|
||||
#define TEMP_SENSOR (31) // P0.31/AIN7
|
||||
#define LUX_SENSOR (29) // P0.29/AIN5
|
||||
|
||||
|
||||
@@ -24,6 +24,17 @@ build_flags = ${nrf52_base.build_flags}
|
||||
-D SX126X_RX_BOOSTED_GAIN=1
|
||||
-D LORA_TX_POWER=22
|
||||
-D P_LORA_TX_LED=13
|
||||
-D UI_RECENT_LIST_SIZE=9
|
||||
-D UI_MSG_PREVIEW_SIZE=165
|
||||
-D EINK_DISPLAY_MODEL=GxEPD2_154_D67
|
||||
-D EINK_SCALE_X=1.5625f
|
||||
-D EINK_SCALE_Y=1.5625f
|
||||
-D EINK_X_OFFSET=0
|
||||
-D EINK_Y_OFFSET=10
|
||||
-D BACKLIGHT_BTN=PIN_BUTTON2
|
||||
-D AUTO_OFF_MILLIS=300000 ; 5 minutes
|
||||
-D UI_NO_HIBERNATE
|
||||
-D DISABLE_DIAGNOSTIC_OUTPUT
|
||||
build_src_filter = ${nrf52_base.build_src_filter}
|
||||
+<helpers/*.cpp>
|
||||
+<ThinkNodeM1Board.cpp>
|
||||
|
||||
@@ -17,6 +17,7 @@ ThinkNodeM1SensorManager sensors = ThinkNodeM1SensorManager(nmea);
|
||||
#ifdef DISPLAY_CLASS
|
||||
DISPLAY_CLASS display;
|
||||
MomentaryButton user_btn(PIN_USER_BTN, 1000, true);
|
||||
MomentaryButton backlight_btn(BACKLIGHT_BTN, 1000, true);
|
||||
#endif
|
||||
|
||||
bool radio_init() {
|
||||
|
||||
@@ -40,6 +40,7 @@ extern ThinkNodeM1SensorManager sensors;
|
||||
#ifdef DISPLAY_CLASS
|
||||
extern DISPLAY_CLASS display;
|
||||
extern MomentaryButton user_btn;
|
||||
extern MomentaryButton backlight_btn;
|
||||
#endif
|
||||
|
||||
bool radio_init();
|
||||
|
||||
@@ -81,7 +81,7 @@
|
||||
#define BUTTON_PIN PIN_BUTTON1
|
||||
#define PIN_USER_BTN BUTTON_PIN
|
||||
|
||||
#define PIN_BUTTON2 (11)
|
||||
#define PIN_BUTTON2 (39)
|
||||
#define BUTTON_PIN2 PIN_BUTTON2
|
||||
|
||||
#define EXTERNAL_FLASH_DEVICES MX25R1635F
|
||||
@@ -131,6 +131,11 @@ extern const int SCK;
|
||||
#define DISP_BUSY (3)
|
||||
#define DISP_BACKLIGHT (43)
|
||||
|
||||
#define PIN_DISPLAY_CS DISP_CS
|
||||
#define PIN_DISPLAY_DC DISP_DC
|
||||
#define PIN_DISPLAY_RST DISP_RST
|
||||
#define PIN_DISPLAY_BUSY DISP_BUSY
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// GPS
|
||||
|
||||
|
||||
Loaded 100 of 123 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user