Merge branch 'develop' into sfpp

src/configuration.h

@@ -444,6 +444,18 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 #endif
 
+// BME680 BSEC2 support detection
+#if !defined(MESHTASTIC_BME680_BSEC2_SUPPORTED)
+#if defined(RAK_4631) || defined(TBEAM_V10)
+
+#define MESHTASTIC_BME680_BSEC2_SUPPORTED 1
+#define MESHTASTIC_BME680_HEADER <bsec2.h>
+#else
+#define MESHTASTIC_BME680_BSEC2_SUPPORTED 0
+#define MESHTASTIC_BME680_HEADER <Adafruit_BME680.h>
+#endif // defined(RAK_4631)
+#endif // !defined(MESHTASTIC_BME680_BSEC2_SUPPORTED)
+
 // -----------------------------------------------------------------------------
 // Global switches to turn off features for a minimized build
 // -----------------------------------------------------------------------------

src/graphics/draw/MenuHandler.cpp

@@ -449,13 +449,14 @@ void menuHandler::clockMenu()
 }
 void menuHandler::messageResponseMenu()
 {
-    enum optionsNumbers { Back = 0, ViewMode, DeleteAll, DeleteOldest, ReplyMenu, Aloud, enumEnd };
+    enum optionsNumbers { Back = 0, ViewMode, DeleteAll, DeleteOldest, ReplyMenu, MuteChannel, Aloud, enumEnd };
 
     static const char *optionsArray[enumEnd];
     static int optionsEnumArray[enumEnd];
     int options = 0;
 
     auto mode = graphics::MessageRenderer::getThreadMode();
+    int threadChannel = graphics::MessageRenderer::getThreadChannel();
 
     optionsArray[options] = "Back";
     optionsEnumArray[options++] = Back;
@@ -467,6 +468,15 @@ void menuHandler::messageResponseMenu()
     optionsArray[options] = "View Chats";
     optionsEnumArray[options++] = ViewMode;
 
+    // If viewing ALL chats, hide “Mute Chat”
+    if (mode != graphics::MessageRenderer::ThreadMode::ALL && mode != graphics::MessageRenderer::ThreadMode::DIRECT) {
+        const uint8_t chIndex = (threadChannel != 0) ? (uint8_t)threadChannel : channels.getPrimaryIndex();
+        auto &chan = channels.getByIndex(chIndex);
+
+        optionsArray[options] = chan.settings.module_settings.is_muted ? "Unmute Channel" : "Mute Channel";
+        optionsEnumArray[options++] = MuteChannel;
+    }
+
     // Delete submenu
     optionsArray[options] = "Delete";
     optionsEnumArray[options++] = 900;
@@ -502,6 +512,14 @@ void menuHandler::messageResponseMenu()
             menuHandler::menuQueue = menuHandler::reply_menu;
             screen->runNow();
 
+        } else if (selected == MuteChannel) {
+            const uint8_t chIndex = (ch != 0) ? (uint8_t)ch : channels.getPrimaryIndex();
+            auto &chan = channels.getByIndex(chIndex);
+            if (chan.settings.has_module_settings) {
+                chan.settings.module_settings.is_muted = !chan.settings.module_settings.is_muted;
+                nodeDB->saveToDisk();
+            }
+
             // Delete submenu
         } else if (selected == 900) {
             menuHandler::menuQueue = menuHandler::delete_messages_menu;

src/mesh/FloodingRouter.cpp

@@ -4,6 +4,7 @@
 #include "configuration.h"
 #include "mesh-pb-constants.h"
 #include "meshUtils.h"
+#include "modules/TextMessageModule.h"
 #if !MESHTASTIC_EXCLUDE_TRACEROUTE
 #include "modules/TraceRouteModule.h"
 #endif
@@ -35,6 +36,10 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
         return true; // we handled it, so stop processing
     }
 
+    if (!seenRecently && !wasUpgraded && textMessageModule) {
+        seenRecently = textMessageModule->recentlySeen(p->id);
+    }
+
     if (seenRecently) {
         printPacket("Ignore dupe incoming msg", p);
         rxDupe++;

src/mesh/RadioInterface.cpp

@@ -246,7 +246,8 @@ uint32_t RadioInterface::getPacketTime(const meshtastic_MeshPacket *p, bool rece
 /** The delay to use for retransmitting dropped packets */
 uint32_t RadioInterface::getRetransmissionMsec(const meshtastic_MeshPacket *p)
 {
-    size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), &meshtastic_Data_msg, &p->decoded);
+    size_t numbytes =p->which_payload_variant == meshtastic_MeshPacket_decoded_tag ? 
+      pb_encode_to_bytes(bytes, sizeof(bytes), &meshtastic_Data_msg, &p->decoded) : p->encrypted.size+MESHTASTIC_HEADER_LENGTH;
     uint32_t packetAirtime = getPacketTime(numbytes + sizeof(PacketHeader));
     // Make sure enough time has elapsed for this packet to be sent and an ACK is received.
     // LOG_DEBUG("Waiting for flooding message with airtime %d and slotTime is %d", packetAirtime, slotTimeMsec);

src/mesh/SX126xInterface.cpp

@@ -62,6 +62,11 @@ template <typename T> bool SX126xInterface<T>::init()
     digitalWrite(LORA_PA_TX_EN, LOW);
 #endif
 
+#ifdef RF95_FAN_EN
+    digitalWrite(RF95_FAN_EN, HIGH);
+    pinMode(RF95_FAN_EN, OUTPUT);
+#endif
+
 #if ARCH_PORTDUINO
     tcxoVoltage = (float)portduino_config.dio3_tcxo_voltage / 1000;
     if (portduino_config.lora_sx126x_ant_sw_pin.pin != RADIOLIB_NC) {
@@ -85,6 +90,13 @@ template <typename T> bool SX126xInterface<T>::init()
         power = -9;
 
     int res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage, useRegulatorLDO);
+
+#ifdef SX126X_PA_RAMP_US
+    // Set custom PA ramp time for boards requiring longer stabilization (e.g., T-Beam 1W needs >800us)
+    if (res == RADIOLIB_ERR_NONE) {
+        lora.setPaRampTime(SX126X_PA_RAMP_US);
+    }
+#endif
     // \todo Display actual typename of the adapter, not just `SX126x`
     LOG_INFO("SX126x init result %d", res);
     if (res == RADIOLIB_ERR_CHIP_NOT_FOUND || res == RADIOLIB_ERR_SPI_CMD_FAILED)

src/modules/SystemCommandsModule.cpp

@@ -45,9 +45,9 @@ int SystemCommandsModule::handleInputEvent(const InputEvent *event)
     // Mute
     case INPUT_BROKER_MSG_MUTE_TOGGLE:
         if (moduleConfig.external_notification.enabled && externalNotificationModule) {
-            externalNotificationModule->setMute(externalNotificationModule->getMute());
+            externalNotificationModule->setMute(!externalNotificationModule->getMute());
             IF_SCREEN(if (!externalNotificationModule->getMute()) externalNotificationModule->stopNow(); screen->showSimpleBanner(
-                externalNotificationModule->getMute() ? "Notifications\nEnabled" : "Notifications\nDisabled", 3000);)
+                externalNotificationModule->getMute() ? "Notifications\nDisabled" : "Notifications\nEnabled", 3000);)
         }
         return 0;
     // Bluetooth

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -53,7 +53,7 @@ extern void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const c
 #include "Sensor/LTR390UVSensor.h"
 #endif
 
-#if __has_include(<bsec2.h>)
+#if __has_include(MESHTASTIC_BME680_HEADER)
 #include "Sensor/BME680Sensor.h"
 #endif
 
@@ -214,7 +214,7 @@ void EnvironmentTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner)
 #if __has_include(<Adafruit_LTR390.h>)
     addSensor<LTR390UVSensor>(i2cScanner, ScanI2C::DeviceType::LTR390UV);
 #endif
-#if __has_include(<bsec2.h>)
+#if __has_include(MESHTASTIC_BME680_HEADER)
     addSensor<BME680Sensor>(i2cScanner, ScanI2C::DeviceType::BME_680);
 #endif
 #if __has_include(<Adafruit_BMP280.h>)

src/modules/Telemetry/Sensor/BME680Sensor.cpp

@@ -1,6 +1,6 @@
 #include "configuration.h"
 
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<bsec2.h>)
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(MESHTASTIC_BME680_HEADER)
 
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
 #include "BME680Sensor.h"
@@ -10,6 +10,7 @@
 
 BME680Sensor::BME680Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_BME680, "BME680") {}
 
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
 int32_t BME680Sensor::runOnce()
 {
     if (!bme680.run()) {
@@ -17,10 +18,13 @@ int32_t BME680Sensor::runOnce()
     }
     return 35;
 }
+#endif // defined(MESHTASTIC_BME680_BSEC2_SUPPORTED)
 
 bool BME680Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     status = 0;
+
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
     if (!bme680.begin(dev->address.address, *bus))
         checkStatus("begin");
 
@@ -42,12 +46,25 @@ bool BME680Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
     if (status == 0)
         LOG_DEBUG("BME680Sensor::runOnce: bme680.status %d", bme680.status);
 
+#else
+    bme680 = makeBME680(bus);
+
+    if (!bme680->begin(dev->address.address)) {
+        LOG_ERROR("Init sensor: %s failed at begin()", sensorName);
+        return status;
+    }
+
+    status = 1;
+
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
+
     initI2CSensor();
     return status;
 }
 
 bool BME680Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
     if (bme680.getData(BSEC_OUTPUT_RAW_PRESSURE).signal == 0)
         return false;
 
@@ -65,9 +82,27 @@ bool BME680Sensor::getMetrics(meshtastic_Telemetry *measurement)
     // Check if we need to save state to filesystem (every STATE_SAVE_PERIOD ms)
     measurement->variant.environment_metrics.iaq = bme680.getData(BSEC_OUTPUT_IAQ).signal;
     updateState();
+#else
+    if (!bme680->performReading()) {
+        LOG_ERROR("BME680Sensor::getMetrics: performReading failed");
+        return false;
+    }
+
+    measurement->variant.environment_metrics.has_temperature = true;
+    measurement->variant.environment_metrics.has_relative_humidity = true;
+    measurement->variant.environment_metrics.has_barometric_pressure = true;
+    measurement->variant.environment_metrics.has_gas_resistance = true;
+
+    measurement->variant.environment_metrics.temperature = bme680->readTemperature();
+    measurement->variant.environment_metrics.relative_humidity = bme680->readHumidity();
+    measurement->variant.environment_metrics.barometric_pressure = bme680->readPressure() / 100.0F;
+    measurement->variant.environment_metrics.gas_resistance = bme680->readGas() / 1000.0;
+
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
     return true;
 }
 
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
 void BME680Sensor::loadState()
 {
 #ifdef FSCom
@@ -144,5 +179,6 @@ void BME680Sensor::checkStatus(const char *functionName)
     else if (bme680.sensor.status > BME68X_OK)
         LOG_WARN("%s BME68X code: %d", functionName, bme680.sensor.status);
 }
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
 
 #endif

src/modules/Telemetry/Sensor/BME680Sensor.h

@@ -1,23 +1,40 @@
 #include "configuration.h"
 
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<bsec2.h>)
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(MESHTASTIC_BME680_HEADER)
 
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
 #include "TelemetrySensor.h"
+
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
+#include <bme68xLibrary.h>
 #include <bsec2.h>
+#else
+#include <Adafruit_BME680.h>
+#include <memory>
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
 
 #define STATE_SAVE_PERIOD UINT32_C(360 * 60 * 1000) // That's 6 hours worth of millis()
 
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
 const uint8_t bsec_config[] = {
 #include "config/bme680/bme680_iaq_33v_3s_4d/bsec_iaq.txt"
 };
-
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
 class BME680Sensor : public TelemetrySensor
 {
   private:
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
     Bsec2 bme680;
+#else
+    using BME680Ptr = std::unique_ptr<Adafruit_BME680>;
+
+    static BME680Ptr makeBME680(TwoWire *bus) { return std::make_unique<Adafruit_BME680>(bus); }
+
+    BME680Ptr bme680;
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
 
   protected:
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
     const char *bsecConfigFileName = "/prefs/bsec.dat";
     uint8_t bsecState[BSEC_MAX_STATE_BLOB_SIZE] = {0};
     uint8_t accuracy = 0;
@@ -34,10 +51,13 @@ class BME680Sensor : public TelemetrySensor
     void loadState();
     void updateState();
     void checkStatus(const char *functionName);
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
 
   public:
     BME680Sensor();
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
     virtual int32_t runOnce() override;
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
     virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };

src/modules/TextMessageModule.cpp

@@ -17,6 +17,9 @@ ProcessMessage TextMessageModule::handleReceived(const meshtastic_MeshPacket &mp
     auto &p = mp.decoded;
     LOG_INFO("Received text msg from=0x%0x, id=0x%x, msg=%.*s", mp.from, mp.id, p.payload.size, p.payload.bytes);
 #endif
+    // add packet ID to the rolling list of packets
+    textPacketList[textPacketListIndex] = mp.id;
+    textPacketListIndex = (textPacketListIndex + 1) % TEXT_PACKET_LIST_SIZE;
 
     // We only store/display messages destined for us.
     devicestate.rx_text_message = mp;
@@ -47,3 +50,13 @@ bool TextMessageModule::wantPacket(const meshtastic_MeshPacket *p)
 {
     return MeshService::isTextPayload(p);
 }
+
+bool TextMessageModule::recentlySeen(uint32_t id)
+{
+    for (size_t i = 0; i < TEXT_PACKET_LIST_SIZE; i++) {
+        if (textPacketList[i] != 0 && textPacketList[i] == id) {
+            return true;
+        }
+    }
+    return false;
+}

src/modules/TextMessageModule.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "Observer.h"
 #include "SinglePortModule.h"
+#define TEXT_PACKET_LIST_SIZE 50
 
 /**
  * Text message handling for Meshtastic.
@@ -19,6 +20,8 @@ class TextMessageModule : public SinglePortModule, public Observable<const mesht
      */
     TextMessageModule() : SinglePortModule("text", meshtastic_PortNum_TEXT_MESSAGE_APP) {}
 
+    bool recentlySeen(uint32_t id);
+
   protected:
     /** Called to handle a particular incoming message
      *
@@ -27,6 +30,10 @@ class TextMessageModule : public SinglePortModule, public Observable<const mesht
      */
     virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
     virtual bool wantPacket(const meshtastic_MeshPacket *p) override;
+
+  private:
+    uint32_t textPacketList[TEXT_PACKET_LIST_SIZE] = {0};
+    size_t textPacketListIndex = 0;
 };
 
 extern TextMessageModule *textMessageModule;