Add timed cw and cw2 commands for SX1262 and LR1110
Support fractional seconds, guard active packet work, keep the MCU awake, and restore reception after carrier tests. Include regression coverage and independent-radio RF validation for the V4 and T1000-E.
This commit is contained in:
1 parent
239f6a84f5
commit
9de1373bd9
27 files changed
+1153
-2
No files matched your search
@@ -309,6 +309,9 @@ void Dispatcher::loop() {
|
||||
next_floor_calib_time = futureMillis(NOISE_FLOOR_CALIB_INTERVAL);
|
||||
}
|
||||
_radio->loop();
|
||||
// A maintenance carrier has no TxDone packet. Keep its deadline serviced,
|
||||
// but leave queued packets and RX/AGC watchdogs alone until normal RX returns.
|
||||
if (_radio->isCarrierWaveActive()) return;
|
||||
|
||||
const unsigned long now = _ms->getMillis();
|
||||
// check for radio 'stuck' in mode other than Rx
|
||||
@@ -590,6 +593,7 @@ bool Dispatcher::tryParsePacket(Packet* pkt, const uint8_t* raw, int len) {
|
||||
}
|
||||
|
||||
void Dispatcher::checkRecv() {
|
||||
if (_radio->isCarrierWaveActive()) return;
|
||||
Packet* pkt;
|
||||
float score;
|
||||
float snr;
|
||||
@@ -697,6 +701,7 @@ void Dispatcher::processRecvPacket(Packet* pkt) {
|
||||
}
|
||||
|
||||
void Dispatcher::checkSend() {
|
||||
if (_radio->isCarrierWaveActive()) return;
|
||||
const uint32_t now = _ms->getMillis();
|
||||
uint32_t next_outbound;
|
||||
if (_mgr->getNextOutboundTime(now, next_outbound)) {
|
||||
|
||||
@@ -31,6 +31,16 @@ public:
|
||||
*/
|
||||
class Radio {
|
||||
public:
|
||||
static constexpr uint32_t CarrierWaveDefaultMillis = 10000;
|
||||
static constexpr uint32_t CarrierWaveMaxMillis = 60000;
|
||||
virtual bool supportsCarrierWave() const { return false; }
|
||||
// duration_ms == 0 stops either carrier; there is one physical transmitter.
|
||||
virtual RadioParamApplyResult setCarrierWave(uint8_t profile, uint32_t duration_ms) {
|
||||
return RadioParamApplyResult::FAILED;
|
||||
}
|
||||
virtual bool isCarrierWaveActive() const { return false; }
|
||||
virtual uint8_t carrierWaveProfile() const { return 0; }
|
||||
virtual uint32_t carrierWaveRemainingMillis() const { return 0; }
|
||||
virtual void begin() { }
|
||||
virtual RadioProfiles* profiles() { return nullptr; }
|
||||
virtual const RadioProfiles* profiles() const { return nullptr; }
|
||||
|
||||
@@ -128,7 +128,10 @@ namespace mesh {
|
||||
#define BD_STARTUP_RX_PACKET 1
|
||||
|
||||
class MainBoard {
|
||||
bool _radio_test_active = false;
|
||||
public:
|
||||
void setRadioTestActive(bool active) { _radio_test_active = active; }
|
||||
bool isRadioTestActive() const { return _radio_test_active; }
|
||||
virtual uint16_t getBattMilliVolts() = 0;
|
||||
virtual float getMCUTemperature() { return NAN; }
|
||||
virtual bool setAdcMultiplier(float multiplier) { return false; };
|
||||
@@ -152,6 +155,7 @@ public:
|
||||
virtual void onBootComplete() { /* no op */ }
|
||||
virtual uint32_t getIRQGpio() { return -1; } // not supported. Returns DIO1 (SX1262) and DIO0 (SX127x)
|
||||
virtual void sleep(uint32_t secs) {
|
||||
if (isRadioTestActive()) return;
|
||||
(void)secs;
|
||||
#if defined(RP2040_PLATFORM) || defined(STM32_PLATFORM)
|
||||
// These platforms have no shared deep-sleep board implementation. WFI is
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
#pragma once
|
||||
|
||||
#include <Dispatcher.h>
|
||||
#include <helpers/CLICommandUtils.h>
|
||||
|
||||
namespace mesh {
|
||||
|
||||
// Volatile maintenance commands shared by every role using RadioProfileCLI.
|
||||
inline bool handleCarrierWaveCommand(Radio* radio, const char* command,
|
||||
char* reply, size_t capacity) {
|
||||
const char* text = command;
|
||||
bool query = false;
|
||||
if (!strncmp(text, "get ", 4)) { text += 4; query = true; }
|
||||
else if (!strncmp(text, "set ", 4)) text += 4;
|
||||
const size_t length = strcspn(text, " \t");
|
||||
const bool secondary = length == 3 && !strncmp(text, "cw2", 3);
|
||||
if (!secondary && !(length == 2 && !strncmp(text, "cw", 2))) return false;
|
||||
const char* name = secondary ? "cw2" : "cw";
|
||||
const char* args = cli::skipRecentRepeaterSpaces(text + length);
|
||||
if (!radio || !radio->supportsCarrierWave()) {
|
||||
snprintf(reply, capacity, "Error: CW unsupported on this radio");
|
||||
return true;
|
||||
}
|
||||
if (!*args) {
|
||||
if (radio->isCarrierWaveActive()) {
|
||||
const uint32_t remaining = radio->carrierWaveRemainingMillis();
|
||||
snprintf(reply, capacity, "> %s on; %lu.%03lu seconds left",
|
||||
radio->carrierWaveProfile() ? "cw2" : "cw",
|
||||
(unsigned long)(remaining / 1000), (unsigned long)(remaining % 1000));
|
||||
} else snprintf(reply, capacity, "> off");
|
||||
return true;
|
||||
}
|
||||
uint32_t duration = 0;
|
||||
const size_t action_length = strcspn(args, " \t");
|
||||
const char* seconds = cli::skipRecentRepeaterSpaces(args + action_length);
|
||||
const bool on = action_length == 2 && !strncmp(args, "on", 2);
|
||||
const bool off = action_length == 3 && !strncmp(args, "off", 3);
|
||||
bool valid = !query && (on || (off && !*seconds));
|
||||
if (on) {
|
||||
duration = Radio::CarrierWaveDefaultMillis;
|
||||
if (*seconds) {
|
||||
float value;
|
||||
valid = valid && cli::parseDecimalStrict(seconds, value)
|
||||
&& value >= 0.001f && value <= Radio::CarrierWaveMaxMillis / 1000.0f;
|
||||
if (valid) duration = static_cast<uint32_t>(value * 1000.0f + 0.5f);
|
||||
}
|
||||
}
|
||||
if (!valid) {
|
||||
snprintf(reply, capacity, "Error: use %s on [seconds 0.001-60] | %s off", name, name);
|
||||
return true;
|
||||
}
|
||||
if (on && secondary && (!radio->profiles() || !radio->profiles()->canTransmit(1))) {
|
||||
snprintf(reply, capacity, "Error: cw2 requires active radio2 rxtx");
|
||||
return true;
|
||||
}
|
||||
const auto result = radio->setCarrierWave(secondary ? 1 : 0, duration);
|
||||
if (result == RadioParamApplyResult::BUSY) {
|
||||
snprintf(reply, capacity, "Error: radio busy; stop active CW or retry when idle");
|
||||
} else if (result != RadioParamApplyResult::APPLIED) {
|
||||
snprintf(reply, capacity, "Error: CW transition failed; check radio recovery");
|
||||
} else if (on) {
|
||||
snprintf(reply, capacity, "OK - %s on for %lu.%03lu seconds; RX paused", name,
|
||||
(unsigned long)(duration / 1000), (unsigned long)(duration % 1000));
|
||||
} else snprintf(reply, capacity, "OK - carrier off%s",
|
||||
radio->isInRecvMode() ? ", receive resumed" : "");
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace mesh
|
||||
@@ -103,7 +103,7 @@ public:
|
||||
// Native USB loses its connection in light sleep. An enumerated host
|
||||
// still needs USB serviced when no terminal asserts CDC DTR (for example,
|
||||
// after a Pi closes its serial port). Guard every caller here.
|
||||
bool keep_awake = inhibit_sleep || isUsbHostConnected();
|
||||
bool keep_awake = inhibit_sleep || isUsbHostConnected() || isRadioTestActive();
|
||||
#if MESH_USB_LOGGING_AVAILABLE
|
||||
// A live logging stream must also remain available before a host opens
|
||||
// it and across host disconnects. Compiled-out logging is not a blocker.
|
||||
|
||||
@@ -462,6 +462,7 @@ bool NRF52Board::isUsbHostConnected() {
|
||||
}
|
||||
|
||||
void NRF52Board::sleep(uint32_t secs) {
|
||||
if (isRadioTestActive()) { delay(1); return; }
|
||||
// Clear FPU interrupt flags to avoid insomnia
|
||||
// see errata 87 for details https://docs.nordicsemi.com/bundle/errata_nRF52840_Rev3/page/ERR/nRF52840/Rev3/latest/anomaly_840_87.html
|
||||
#if (__FPU_USED == 1)
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
#include "RadioProfileCLI.h"
|
||||
#include "CarrierWaveCLI.h"
|
||||
#include "RadioProfileCommandUtils.h"
|
||||
#include "radiolib/RXPowerSaving.h"
|
||||
#include <Arduino.h>
|
||||
@@ -274,6 +275,7 @@ void RadioProfileCLI::formatConfig(char* reply, size_t capacity, const RadioProf
|
||||
}
|
||||
|
||||
bool RadioProfileCLI::handle(const char* command, char* reply, size_t capacity) {
|
||||
if (handleCarrierWaveCommand(radio_, command, reply, capacity)) return true;
|
||||
const char* text = command;
|
||||
enum { Get, Set, Delete } verb = Get;
|
||||
if (!strncmp(text, "get ", 4)) text += 4;
|
||||
|
||||
@@ -15,10 +15,14 @@ class CustomLR1110Wrapper : public RadioLibWrapper {
|
||||
public:
|
||||
CustomLR1110Wrapper(CustomLR1110& radio, mesh::MainBoard& board)
|
||||
: RadioLibWrapper(radio, board), _deep_init(NULL) { }
|
||||
bool supportsCarrierWave() const override { return true; }
|
||||
|
||||
void setDeepInitCallback(DeepInitCallback callback) { _deep_init = callback; }
|
||||
|
||||
void powerOff() { _radio->standby(); _radio->sleep(); }
|
||||
void powerOff() {
|
||||
if (isCarrierWaveActive()) setCarrierWave(0, 0);
|
||||
_radio->standby(); _radio->sleep();
|
||||
}
|
||||
|
||||
protected:
|
||||
bool applyParams(float freq, float bw, uint8_t sf, uint8_t cr) override {
|
||||
@@ -37,6 +41,7 @@ protected:
|
||||
|
||||
public:
|
||||
bool setCodingRate(uint8_t cr) override {
|
||||
if (isCarrierWaveActive()) return false;
|
||||
return ((CustomLR1110 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
|
||||
}
|
||||
|
||||
|
||||
@@ -36,6 +36,7 @@ protected:
|
||||
|
||||
public:
|
||||
CustomSX1262Wrapper(CustomSX1262& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
|
||||
bool supportsCarrierWave() const override { return true; }
|
||||
|
||||
protected:
|
||||
int16_t applyCachedTxPower(int8_t dbm) override {
|
||||
@@ -65,6 +66,7 @@ protected:
|
||||
|
||||
public:
|
||||
bool setCodingRate(uint8_t cr) override {
|
||||
if (isCarrierWaveActive()) return false;
|
||||
return ((CustomSX1262 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
|
||||
}
|
||||
|
||||
@@ -84,6 +86,7 @@ public:
|
||||
}
|
||||
uint8_t getSpreadingFactor() const override { return ((CustomSX1262 *)_radio)->spreadingFactor; }
|
||||
void powerOff() {
|
||||
if (isCarrierWaveActive()) setCarrierWave(0, 0);
|
||||
((CustomSX1262 *)_radio)->standby();
|
||||
((CustomSX1262 *)_radio)->sleep(false);
|
||||
}
|
||||
@@ -100,6 +103,7 @@ public:
|
||||
}
|
||||
|
||||
bool setRxPowerSavingRfRxDisabled(bool disabled) override {
|
||||
if (isCarrierWaveActive()) return false;
|
||||
if (!supportsRxPowerSavingRfRxDisable()) return false;
|
||||
|
||||
if (_rx_ps_armed) stopReceiveDutyCycle();
|
||||
|
||||
@@ -105,6 +105,7 @@ bool RadioLibWrapper::setTxPower(int8_t dbm) {
|
||||
}
|
||||
|
||||
uint8_t RadioLibWrapper::beginReconfigure() {
|
||||
if (_cw_active) return 2;
|
||||
const uint8_t base_state = state & ~STATE_INT_READY;
|
||||
// On SX126x/LR11xx duty-cycle RX, BUSY may remain asserted during the sleep
|
||||
// side of the cycle. Do not issue an IRQ/preamble query over SPI then; due
|
||||
@@ -228,6 +229,7 @@ bool RadioLibWrapper::validateProfile(const mesh::RadioProfileParams& p) const {
|
||||
}
|
||||
|
||||
mesh::RadioParamApplyResult RadioLibWrapper::tuneProfile(uint8_t profile) {
|
||||
if (_cw_active) return mesh::RadioParamApplyResult::BUSY;
|
||||
if (profile > 1 || (profile == 1 && !_profiles.enabled())) return mesh::RadioParamApplyResult::FAILED;
|
||||
const auto& p = _profiles.params(profile);
|
||||
const uint16_t preamble = profilePreamble(profile);
|
||||
@@ -292,6 +294,7 @@ mesh::RadioParamApplyResult RadioLibWrapper::prepareTransmitProfile(uint8_t prof
|
||||
}
|
||||
|
||||
void RadioLibWrapper::serviceProfileScan() {
|
||||
if (_cw_active) return;
|
||||
if (!_params_valid || (_profile_retry_at && (int32_t)(millis() - _profile_retry_at) < 0)) return;
|
||||
_profile_retry_at = 0;
|
||||
if (_profiles.enabled() && !_profile_rxps_suspended) {
|
||||
@@ -398,6 +401,7 @@ bool RadioLibWrapper::setRxBoostedGainMode(bool enabled) {
|
||||
}
|
||||
|
||||
void RadioLibWrapper::idle() {
|
||||
if (_cw_active) return;
|
||||
_radio->standby();
|
||||
_rx_hold_continuous = false;
|
||||
state = STATE_IDLE; // need another startReceive()
|
||||
@@ -444,6 +448,7 @@ void RadioLibWrapper::doResetAGC() {
|
||||
}
|
||||
|
||||
void RadioLibWrapper::resetAGC() {
|
||||
if (_cw_active) return;
|
||||
// make sure we're not mid-receiving and mid-sending of packet!
|
||||
if (isPacketPendingOrReceiving() || (state == STATE_TX_WAIT)) return;
|
||||
|
||||
@@ -460,6 +465,7 @@ void RadioLibWrapper::resetAGC() {
|
||||
}
|
||||
|
||||
bool RadioLibWrapper::recoverRadio(bool hard) {
|
||||
if (_cw_active) return false;
|
||||
const uint8_t base_state = state & ~STATE_INT_READY;
|
||||
if ((state & STATE_INT_READY) != 0 || base_state == STATE_TX_WAIT) return false;
|
||||
|
||||
@@ -658,7 +664,98 @@ void RadioLibWrapper::checkReceiveMode(uint32_t now) {
|
||||
recoverRadio(_rx_mode_failures >= 3);
|
||||
}
|
||||
|
||||
uint32_t RadioLibWrapper::carrierWaveRemainingMillis() const {
|
||||
if (!_cw_active || _cw_stopping) return 0;
|
||||
const int32_t remaining = static_cast<int32_t>(_cw_until - millis());
|
||||
return remaining > 0 ? static_cast<uint32_t>(remaining) : 0;
|
||||
}
|
||||
|
||||
mesh::RadioParamApplyResult RadioLibWrapper::setCarrierWave(uint8_t profile, uint32_t duration_ms) {
|
||||
using Result = mesh::RadioParamApplyResult;
|
||||
if (!supportsCarrierWave()) return Result::FAILED;
|
||||
if (!duration_ms) return !_cw_active || stopCarrierWave() ? Result::APPLIED : Result::FAILED;
|
||||
if (profile > 1 || duration_ms > CarrierWaveMaxMillis || !_params_valid
|
||||
|| !_profiles.canTransmit(profile)) return Result::FAILED;
|
||||
if (_cw_active) {
|
||||
if (_cw_stopping || profile != _cw_profile
|
||||
|| _cw_generation != _profiles.generation[profile]) return Result::BUSY;
|
||||
_cw_until = static_cast<uint32_t>(millis()) + duration_ms;
|
||||
return Result::APPLIED;
|
||||
}
|
||||
|
||||
// Own an idle radio before changing profiles or keying the external FEM.
|
||||
// This also performs the SX1262 duty-cycle RTC cleanup used by packet TX.
|
||||
const uint8_t resume = beginReconfigure();
|
||||
if (resume > 1) return Result::BUSY;
|
||||
_cw_restore_profile = _active_profile;
|
||||
if (_radio->standby() != RADIOLIB_ERR_NONE
|
||||
|| _radio->clearIrqFlags(UINT32_MAX) != RADIOLIB_ERR_NONE
|
||||
|| tuneProfile(profile) != Result::APPLIED) {
|
||||
startRecv();
|
||||
return Result::FAILED;
|
||||
}
|
||||
_radio->clearPacketReceivedAction();
|
||||
state = STATE_IDLE;
|
||||
_rx_ps_armed = false;
|
||||
_rx_hold_continuous = false;
|
||||
_nf_calib_active = false;
|
||||
_wd_observe_until = 0;
|
||||
_cw_profile = profile;
|
||||
_cw_generation = _profiles.generation[profile];
|
||||
_cw_active = true;
|
||||
_cw_stopping = false;
|
||||
_board->setRadioTestActive(true); // service the deadline even without USB
|
||||
_board->onBeforeTransmit();
|
||||
_cw_board_tx = true;
|
||||
if (_radio->transmitDirect() != RADIOLIB_ERR_NONE) {
|
||||
stopCarrierWave(); // a failed SPI result does not prove TX stayed off
|
||||
return Result::FAILED;
|
||||
}
|
||||
_cw_until = static_cast<uint32_t>(millis()) + duration_ms;
|
||||
return Result::APPLIED;
|
||||
}
|
||||
|
||||
bool RadioLibWrapper::stopCarrierWave() {
|
||||
_cw_stopping = true;
|
||||
// finishTransmit clears radio IRQs and enters standby on both supported
|
||||
// families. Deassert external TX even if SPI fails, then try a radio reset.
|
||||
const int16_t status = _radio->finishTransmit();
|
||||
if (_cw_board_tx) { _board->onAfterTransmit(); _cw_board_tx = false; }
|
||||
if (status != RADIOLIB_ERR_NONE && !restoreAfterDeepInit()) {
|
||||
_cw_retry_at = static_cast<uint32_t>(millis()) + 100;
|
||||
return false; // hold normal work until stopping the carrier is confirmed
|
||||
}
|
||||
_cw_active = false;
|
||||
_cw_stopping = false;
|
||||
_rx_ps_armed = false;
|
||||
state = STATE_IDLE;
|
||||
_radio->setPacketReceivedAction(setFlag);
|
||||
_profile_refresh_required = true;
|
||||
const uint8_t restore = _profiles.enabled() ? _cw_restore_profile : 0;
|
||||
const bool tuned = tuneProfile(restore) == mesh::RadioParamApplyResult::APPLIED;
|
||||
recalibrateNoiseFloor();
|
||||
startRecv();
|
||||
if (!isInRecvMode() && restoreAfterDeepInit()) startRecv();
|
||||
_board->setRadioTestActive(false);
|
||||
return tuned && isInRecvMode();
|
||||
}
|
||||
|
||||
bool RadioLibWrapper::serviceCarrierWave() {
|
||||
if (_cw_active) {
|
||||
const uint32_t now = millis();
|
||||
if ((_cw_stopping && static_cast<int32_t>(now - _cw_retry_at) >= 0)
|
||||
|| (!_cw_stopping && (static_cast<int32_t>(now - _cw_until) >= 0
|
||||
|| !_profiles.canTransmit(_cw_profile)
|
||||
|| _cw_generation != _profiles.generation[_cw_profile]))) {
|
||||
if (!stopCarrierWave()) MESH_DEBUG_PRINTLN("CW: stop/RX recovery failed");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void RadioLibWrapper::loop() {
|
||||
if (serviceCarrierWave()) return;
|
||||
serviceProfileScan();
|
||||
// Calibration batches need one stable channel. Do not publish a noise floor
|
||||
// assembled from different frequencies, or let a batch pin the scan on one.
|
||||
@@ -744,6 +841,7 @@ void RadioLibWrapper::loop() {
|
||||
}
|
||||
|
||||
void RadioLibWrapper::startRecv() {
|
||||
if (_cw_active) return;
|
||||
int err = startReceiveMode();
|
||||
if (err == RADIOLIB_ERR_NONE) {
|
||||
// A very short frame may complete while startReceiveMode() returns.
|
||||
@@ -807,6 +905,7 @@ bool RadioLibWrapper::isInRecvMode() const {
|
||||
|
||||
// RX PowerSaving
|
||||
bool RadioLibWrapper::setRxPowerSaving(bool enabled, uint32_t rx_us, uint32_t sleep_us) {
|
||||
if (_cw_active) return false;
|
||||
if (_profile_rxps_suspended) {
|
||||
_profile_saved_rxps = enabled;
|
||||
_rx_ps_rx_us = rx_us;
|
||||
@@ -830,6 +929,7 @@ bool RadioLibWrapper::setRxPowerSaving(bool enabled, uint32_t rx_us, uint32_t sl
|
||||
}
|
||||
|
||||
int RadioLibWrapper::recvRaw(uint8_t* bytes, int sz) {
|
||||
if (_cw_active) return 0;
|
||||
int len = 0;
|
||||
if (state & STATE_INT_READY) {
|
||||
last_radio_interrupt_millis = millis(); // ISR fired -> radio hardware is alive
|
||||
@@ -921,6 +1021,7 @@ uint32_t RadioLibWrapper::getEstAirtimeFor(int len_bytes) {
|
||||
}
|
||||
|
||||
bool RadioLibWrapper::startSendRaw(const uint8_t* bytes, int len) {
|
||||
if (_cw_active) return false;
|
||||
_rx_hold_continuous = false;
|
||||
if (_rx_ps_armed) {
|
||||
// stop the duty-cycle sequencer before SetTx, otherwise its next RTC
|
||||
@@ -989,6 +1090,7 @@ int16_t RadioLibWrapper::performChannelScanWithTimeout(unsigned long timeout_ms)
|
||||
}
|
||||
|
||||
bool RadioLibWrapper::isChannelActive() {
|
||||
if (_cw_active) return true;
|
||||
if (isPacketPendingOrReceiving() || (state & ~STATE_INT_READY) == STATE_TX_WAIT) return true;
|
||||
// int.thresh: RSSI-based interference detection (relative to noise floor).
|
||||
// In RX duty-cycle mode only checked while the chip is in a listen window
|
||||
@@ -1020,6 +1122,7 @@ bool RadioLibWrapper::isChannelActive() {
|
||||
}
|
||||
|
||||
bool RadioLibWrapper::isReceivingPassive(int interference_margin_db) {
|
||||
if (_cw_active) return true;
|
||||
// RX duty-cycle radios hold BUSY high while asleep. Do not attempt an SPI
|
||||
// IRQ/RSSI read until the next listen window. Treat the unknown channel as
|
||||
// busy so the retry is deferred instead of transmitting blind; Dispatcher
|
||||
|
||||
@@ -83,6 +83,13 @@ protected:
|
||||
bool _profile_rxps_suspended = false;
|
||||
bool _profile_saved_rxps = false;
|
||||
bool _profile_refresh_required = false;
|
||||
bool _cw_active = false;
|
||||
bool _cw_stopping = false;
|
||||
bool _cw_board_tx = false;
|
||||
uint8_t _cw_profile = 0, _cw_restore_profile = 0;
|
||||
uint32_t _cw_until = 0, _cw_retry_at = 0, _cw_generation = 0;
|
||||
bool stopCarrierWave();
|
||||
bool serviceCarrierWave();
|
||||
mesh::RadioParamApplyResult tuneProfile(uint8_t profile);
|
||||
void serviceProfileScan();
|
||||
|
||||
@@ -187,6 +194,10 @@ public:
|
||||
}
|
||||
|
||||
void begin() override;
|
||||
mesh::RadioParamApplyResult setCarrierWave(uint8_t profile, uint32_t duration_ms) override;
|
||||
bool isCarrierWaveActive() const override { return _cw_active; }
|
||||
uint8_t carrierWaveProfile() const override { return _cw_profile; }
|
||||
uint32_t carrierWaveRemainingMillis() const override;
|
||||
mesh::RadioProfiles* profiles() override { return &_profiles; }
|
||||
const mesh::RadioProfiles* profiles() const override { return &_profiles; }
|
||||
bool validateProfile(const mesh::RadioProfileParams& params) const override;
|
||||
|
||||
Reference in new issue
Block a user