Merge pull request #3784 from Maxwell456/feature/repeater-history

Add min/max/avg history queries to repeaters
This commit is contained in:
fdlamotte authored and GitHub committed 2026-11-10 12:42:53 -04:00
commit 66d404eac8
14 files changed
+530 -85

No files matched your search

+103 -5
View File
@@ -1,5 +1,8 @@
#include "MyMesh.h"
#include <algorithm>
#if REPEATER_HISTORY_SLOTS > 0
#include <helpers/sensors/LPPDataHelpers.h>
#endif
/* ------------------------------ Config -------------------------------- */
@@ -46,6 +49,9 @@
#define REQ_TYPE_GET_STATUS 0x01 // same as _GET_STATS
#define REQ_TYPE_KEEP_ALIVE 0x02
#define REQ_TYPE_GET_TELEMETRY_DATA 0x03
#if REPEATER_HISTORY_SLOTS > 0
#define REQ_TYPE_GET_AVG_MIN_MAX 0x04
#endif
#define REQ_TYPE_GET_ACCESS_LIST 0x05
#define REQ_TYPE_GET_NEIGHBOURS 0x06
#define REQ_TYPE_GET_OWNER_INFO 0x07 // FIRMWARE_VER_LEVEL >= 2
@@ -209,6 +215,7 @@ uint8_t MyMesh::handleAnonClockReq(const mesh::Identity& sender, uint32_t sender
}
int MyMesh::handleRequest(ClientInfo *sender, uint32_t sender_timestamp, uint8_t *payload, size_t payload_len) {
if (payload_len == 0) return 0;
// uint32_t now = getRTCClock()->getCurrentTimeUnique();
// memcpy(reply_data, &now, 4); // response packets always prefixed with timestamp
memcpy(reply_data, &sender_timestamp, 4); // reflect sender_timestamp back in response packet (kind of like a 'tag')
@@ -259,6 +266,48 @@ int MyMesh::handleRequest(ClientInfo *sender, uint32_t sender_timestamp, uint8_t
memcpy(&reply_data[4], telemetry.getBuffer(), tlen);
return 4 + tlen; // reply_len
}
#if REPEATER_HISTORY_SLOTS > 0
if (payload[0] == REQ_TYPE_GET_AVG_MIN_MAX && payload_len >= 11 &&
(sender->permissions & PERM_ACL_ROLE_MASK) >= PERM_ACL_READ_ONLY) {
uint32_t start_secs_ago, end_secs_ago;
memcpy(&start_secs_ago, &payload[1], 4);
memcpy(&end_secs_ago, &payload[5], 4);
MinMaxAvg data[8];
int n = 0;
if (payload[9] == 0 && payload[10] == 0) {
uint32_t now_secs = uptime_millis / 1000;
battery_history.calcMinMaxAvg(now_secs, start_secs_ago, end_secs_ago, &data[n++], HISTORY_BATTERY,
LPP_VOLTAGE);
noise_history.calcMinMaxAvg(now_secs, start_secs_ago, end_secs_ago, &data[n++], HISTORY_NOISE,
LPP_ANALOG_INPUT);
tx_history.calcMinMaxAvg(now_secs, start_secs_ago, end_secs_ago, &data[n++], HISTORY_TX,
LPP_PERCENTAGE);
rx_history.calcMinMaxAvg(now_secs, start_secs_ago, end_secs_ago, &data[n++], HISTORY_RX,
LPP_PERCENTAGE);
temperature_history.calcMinMaxAvg(now_secs, start_secs_ago, end_secs_ago, &data[n], HISTORY_TEMPERATURE,
LPP_TEMPERATURE);
// Unsupported temperature sensors and empty ranges have no encodable LPP value.
if (!isnan(data[n]._avg)) n++;
}
uint8_t ofs = 4;
uint32_t now = getRTCClock()->getCurrentTime();
memcpy(&reply_data[ofs], &now, 4);
ofs += 4;
for (int i = 0; i < n; i++) {
auto d = &data[i];
if (isnan(d->_avg)) continue;
reply_data[ofs++] = d->_channel;
reply_data[ofs++] = d->_lpp_type;
uint8_t sz = LPPData::getDataSize(d->_lpp_type);
uint32_t mult = LPPData::getMultiplier(d->_lpp_type);
bool is_signed = LPPData::isSigned(d->_lpp_type);
ofs += LPPData::putFloat(&reply_data[ofs], d->_min, sz, mult, is_signed);
ofs += LPPData::putFloat(&reply_data[ofs], d->_max, sz, mult, is_signed);
ofs += LPPData::putFloat(&reply_data[ofs], d->_avg, sz, mult, is_signed);
}
return ofs;
}
#endif
if (payload[0] == REQ_TYPE_GET_ACCESS_LIST && sender->isAdmin()) {
uint8_t res1 = payload[1]; // reserved for future (extra query params)
uint8_t res2 = payload[2];
@@ -862,6 +911,13 @@ void MyMesh::sendNodeDiscoverReq() {
MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondClock &ms, mesh::RNG &rng,
mesh::RTCClock &rtc, mesh::MeshTables &tables)
: mesh::Mesh(radio, ms, rng, rtc, *new StaticPoolPacketManager(32), tables),
#if REPEATER_HISTORY_SLOTS > 0
battery_history(REPEATER_HISTORY_SLOTS, REPEATER_HISTORY_INTERVAL_SECS),
noise_history(REPEATER_HISTORY_SLOTS, REPEATER_HISTORY_INTERVAL_SECS),
tx_history(REPEATER_HISTORY_SLOTS, REPEATER_HISTORY_INTERVAL_SECS),
rx_history(REPEATER_HISTORY_SLOTS, REPEATER_HISTORY_INTERVAL_SECS),
temperature_history(REPEATER_HISTORY_SLOTS, REPEATER_HISTORY_INTERVAL_SECS),
#endif
region_map(key_store), temp_map(key_store),
_cli(board, rtc, sensors, region_map, acl, &_prefs, this),
telemetry(MAX_PACKET_PAYLOAD - 4),
@@ -876,6 +932,12 @@ MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondCloc
{
last_millis = 0;
uptime_millis = 0;
#if REPEATER_HISTORY_SLOTS > 0
history_last_secs = history_battery_secs = history_airtime_secs = 0;
history_tx_millis = history_rx_millis = 0;
history_battery_total = 0;
history_battery_count = 0;
#endif
next_local_advert = next_flood_advert = 0;
dirty_contacts_expiry = 0;
set_radio_at = revert_radio_at = 0;
@@ -1286,7 +1348,48 @@ void MyMesh::handleCommand(uint32_t sender_timestamp, char *command, char *reply
}
}
#if REPEATER_HISTORY_SLOTS > 0
void MyMesh::recordHistory() {
uint32_t now_secs = uptime_millis / 1000;
// Average periodic reads without repeatedly enabling the battery divider.
if (uint32_t(now_secs - history_battery_secs) >= 15) {
history_battery_total += board.getBattMilliVolts();
history_battery_count++;
history_battery_secs = now_secs;
}
uint32_t elapsed_secs = now_secs - history_last_secs;
if (elapsed_secs < REPEATER_HISTORY_INTERVAL_SECS) return;
// Advance the sampling grid without accumulating loop delays or replaying missed slots.
history_last_secs += (elapsed_secs / REPEATER_HISTORY_INTERVAL_SECS) * REPEATER_HISTORY_INTERVAL_SECS;
uint32_t airtime_elapsed_secs = now_secs - history_airtime_secs;
if (history_battery_count > 0) {
battery_history.recordData(history_last_secs, history_battery_total / history_battery_count / 1000.0f);
}
int noise_floor = _radio->getNoiseFloor();
if (noise_floor != 0) noise_history.recordData(history_last_secs, noise_floor); // zero means uncalibrated
uint32_t tx_millis = getTotalAirTime();
uint32_t rx_millis = getReceiveAirTime();
// Counters are milliseconds; unsigned subtraction also handles their wrap.
tx_history.recordData(history_last_secs, uint32_t(tx_millis - history_tx_millis) / (airtime_elapsed_secs * 10.0f));
rx_history.recordData(history_last_secs, uint32_t(rx_millis - history_rx_millis) / (airtime_elapsed_secs * 10.0f));
temperature_history.recordData(history_last_secs, board.getMCUTemperature()); // ignores NaN
history_airtime_secs = now_secs;
history_tx_millis = tx_millis;
history_rx_millis = rx_millis;
history_battery_total = 0;
history_battery_count = 0;
}
#endif
void MyMesh::loop() {
// Update before dispatching requests, including across millis() wrap.
uint32_t now = millis();
uptime_millis += uint32_t(now - last_millis);
last_millis = now;
#if REPEATER_HISTORY_SLOTS > 0
recordHistory();
#endif
#ifdef WITH_BRIDGE
bridge.loop();
#endif
@@ -1324,11 +1427,6 @@ void MyMesh::loop() {
acl.save(_fs);
dirty_contacts_expiry = 0;
}
// update uptime
uint32_t now = millis();
uptime_millis += now - last_millis;
last_millis = now;
}
// To check if there is pending work
+26
View File
@@ -37,6 +37,22 @@
#include <helpers/RoutingPolicy.h>
#include "RateLimiter.h"
#ifndef REPEATER_HISTORY_SLOTS
#if defined(STM32_PLATFORM) || defined(RP2040_PLATFORM)
#define REPEATER_HISTORY_SLOTS 0
#else
#define REPEATER_HISTORY_SLOTS 288
#endif
#endif
#ifndef REPEATER_HISTORY_INTERVAL_SECS
#define REPEATER_HISTORY_INTERVAL_SECS 300
#endif
#if REPEATER_HISTORY_SLOTS > 0
#include <helpers/TimeSeriesData.h>
static_assert(REPEATER_HISTORY_INTERVAL_SECS > 0, "History interval must be positive");
#endif
#ifdef WITH_BRIDGE
extern AbstractBridge* bridge;
#endif
@@ -82,6 +98,16 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
FILESYSTEM* _fs;
uint32_t last_millis;
uint64_t uptime_millis;
#if REPEATER_HISTORY_SLOTS > 0
// Dedicated history channels 200..204; environment telemetry occupies 1..17.
enum { HISTORY_BATTERY = 200, HISTORY_NOISE, HISTORY_TX, HISTORY_RX, HISTORY_TEMPERATURE };
TimeSeriesData battery_history, noise_history, tx_history, rx_history, temperature_history;
uint32_t history_last_secs, history_battery_secs, history_airtime_secs;
uint32_t history_tx_millis, history_rx_millis;
float history_battery_total;
uint32_t history_battery_count;
void recordHistory();
#endif
unsigned long next_local_advert, next_flood_advert;
bool _logging;
NodePrefs _prefs;
+9 -3
View File
@@ -789,7 +789,9 @@ SensorMesh::SensorMesh(mesh::MainBoard& board, mesh::Radio& radio, mesh::Millise
{
next_local_advert = next_flood_advert = 0;
dirty_contacts_expiry = 0;
last_read_time = 0;
last_read_time = uint32_t(0) - SENSOR_READ_INTERVAL_SECS; // read immediately on the first loop
last_millis = 0;
uptime_millis = 0;
num_alert_tasks = 0;
set_radio_at = revert_radio_at = 0;
recv_pkt_region = NULL;
@@ -999,6 +1001,9 @@ bool SensorMesh::getGPS(uint8_t channel, float& lat, float& lon, float& alt) {
}
void SensorMesh::loop() {
uint32_t now = millis();
uptime_millis += uint32_t(now - last_millis);
last_millis = now;
mesh::Mesh::loop();
if (next_flood_advert && millisHasNowPassed(next_flood_advert)) {
@@ -1028,7 +1033,8 @@ void SensorMesh::loop() {
}
uint32_t curr = getRTCClock()->getCurrentTime();
if (curr >= last_read_time + SENSOR_READ_INTERVAL_SECS) {
uint32_t uptime_secs = getUptimeSeconds();
if (uint32_t(uptime_secs - last_read_time) >= SENSOR_READ_INTERVAL_SECS) {
telemetry.reset();
telemetry.addVoltage(TELEM_CHANNEL_SELF, (float)board.getBattMilliVolts() / 1000.0f);
// query other sensors -- target specific
@@ -1069,7 +1075,7 @@ void SensorMesh::loop() {
onSensorDataRead();
last_read_time = curr;
last_read_time = uptime_secs;
}
// check the alert send queue
+4 -1
View File
@@ -3,7 +3,7 @@
#include <Arduino.h> // needed for PlatformIO
#include <Mesh.h>
#include "TimeSeriesData.h"
#include <helpers/TimeSeriesData.h>
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
#include <InternalFileSystem.h>
@@ -88,6 +88,7 @@ public:
void sendFloodReply(mesh::Packet* packet, unsigned long delay_millis, uint8_t path_hash_size);
protected:
uint32_t getUptimeSeconds() const { return uptime_millis / 1000; }
// current telemetry data queries
float getVoltage(uint8_t channel) { return getTelemValue(channel, LPP_VOLTAGE); }
float getCurrent(uint8_t channel) { return getTelemValue(channel, LPP_CURRENT); }
@@ -154,6 +155,8 @@ private:
RegionEntry* load_stack[8];
TransportKey default_scope;
uint32_t last_read_time;
uint32_t last_millis;
uint64_t uptime_millis;
int matching_peer_indexes[MAX_SEARCH_RESULTS];
int num_alert_tasks;
Trigger* alert_tasks[MAX_CONCURRENT_ALERTS];
-45
View File
@@ -1,45 +0,0 @@
#include "TimeSeriesData.h"
void TimeSeriesData::recordData(mesh::RTCClock* clock, float value) {
uint32_t now = clock->getCurrentTime();
if (now >= last_timestamp + interval_secs) {
last_timestamp = now;
data[next] = value; // append to cycle table
next = (next + 1) % num_slots;
}
}
void TimeSeriesData::calcMinMaxAvg(mesh::RTCClock* clock, uint32_t start_secs_ago, uint32_t end_secs_ago, MinMaxAvg* dest, uint8_t channel, uint8_t lpp_type) const {
int i = next, n = num_slots;
uint32_t ago = clock->getCurrentTime() - last_timestamp;
int num_values = 0;
float total = 0.0f;
dest->_channel = channel;
dest->_lpp_type = lpp_type;
// start at most recet recording, back-track through to oldest
while (n > 0) {
n--;
i = (i + num_slots - 1) % num_slots; // go back by one
if (ago >= end_secs_ago && ago < start_secs_ago) { // filter by the desired time range
float v = data[i];
num_values++;
total += v;
if (num_values == 1) {
dest->_max = dest->_min = v;
} else {
if (v < dest->_min) dest->_min = v;
if (v > dest->_max) dest->_max = v;
}
}
ago += interval_secs;
}
// calc average
if (num_values > 0) {
dest->_avg = total / num_values;
} else {
dest->_max = dest->_min = dest->_avg = NAN;
}
}
+2 -27
View File
@@ -1,29 +1,4 @@
#pragma once
#include <Arduino.h>
#include <Mesh.h>
struct MinMaxAvg {
float _min, _max, _avg;
uint8_t _lpp_type, _channel;
};
class TimeSeriesData {
float* data;
int num_slots, next;
uint32_t last_timestamp;
uint32_t interval_secs;
public:
TimeSeriesData(float* array, int num, uint32_t secs) : num_slots(num), data(array), last_timestamp(0), next(0), interval_secs(secs) {
memset(data, 0, sizeof(float)*num);
}
TimeSeriesData(int num, uint32_t secs) : num_slots(num), last_timestamp(0), next(0), interval_secs(secs) {
data = new float[num];
memset(data, 0, sizeof(float)*num);
}
void recordData(mesh::RTCClock* clock, float value);
void calcMinMaxAvg(mesh::RTCClock* clock, uint32_t start_secs_ago, uint32_t end_secs_ago, MinMaxAvg* dest, uint8_t channel, uint8_t lpp_type) const;
};
// Compatibility include for custom sensor sketches; implementation lives in src/helpers.
#include <helpers/TimeSeriesData.h>
+3 -2
View File
@@ -21,13 +21,14 @@ protected:
void onSensorDataRead() override {
float batt_voltage = getVoltage(TELEM_CHANNEL_SELF);
battery_data.recordData(getRTCClock(), batt_voltage); // record battery
battery_data.recordData(getUptimeSeconds(), batt_voltage); // record battery
alertIf(batt_voltage < 3.4f, critical_batt, HIGH_PRI_ALERT, "Battery is critical!");
alertIf(batt_voltage < 3.6f, low_batt, LOW_PRI_ALERT, "Battery is low");
}
int querySeriesData(uint32_t start_secs_ago, uint32_t end_secs_ago, MinMaxAvg dest[], int max_num) override {
battery_data.calcMinMaxAvg(getRTCClock(), start_secs_ago, end_secs_ago, &dest[0], TELEM_CHANNEL_SELF, LPP_VOLTAGE);
battery_data.calcMinMaxAvg(getUptimeSeconds(), start_secs_ago, end_secs_ago, &dest[0], TELEM_CHANNEL_SELF,
LPP_VOLTAGE);
return 1;
}