Bump to 1.2.50

Support for replies and tap backs

.gitlab-ci.yml

@@ -0,0 +1,50 @@
+image: python:latest
+
+variables:
+  # make sure GitLab check out submodules
+  GIT_SUBMODULE_STRATEGY: recursive
+
+stages:
+  - buildall
+  - upload
+
+build:
+  stage: buildall
+
+  before_script:
+    # we need zip later for packaging
+    - "apt update;apt -y install zip"
+    - "pip install -U platformio"
+
+  script:
+    # clean up residues from previous run
+    - rm -rf release
+    - bin/build-all.sh
+
+  # This is for my local environment, if your runners are tagged differently, modify or remove  
+  tags:
+    - dockerized
+
+  # The files which are to be made available in GitLab
+  artifacts:
+    paths:
+      - release/archive/firmware*.zip
+
+
+upload:
+  image: curlimages/curl:latest
+
+  stage: upload
+
+  script:
+    - |
+      PACKAGE_REGISTRY_URL="${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/${CI_PROJECT_NAME}/master"
+      cd release/archive
+      for f in *.zip; do
+      curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file ${f} ${PACKAGE_REGISTRY_URL}/${f}
+      done
+      echo 'Package uploaded!'
+      
+  # This is for my local environment, if your runners are tagged differently, modify or remove
+  tags:
+    - dockerized  

.vscode/settings.json

@@ -50,7 +50,8 @@
         "cassert": "cpp",
         "iterator": "cpp",
         "shared_mutex": "cpp",
-        "iostream": "cpp"
+        "iostream": "cpp",
+        "esp_nimble_hci.h": "c"
     },
     "cSpell.words": [
         "Blox",

bin/build-nightly.sh

@@ -1,38 +0,0 @@
-#!/bin/bash
-source ~/.bashrc
-
-# Meshtastic Nightly Build Script.
-#  McHamster (jm@casler.org)
-#
-# This is the script that is used for the nightly build server.
-#
-# It's probably not useful for most people, but you may want to run your own
-#   nightly builds.
-#
-# The last line of ~/.bashrc contains an inclusion of platformio in the path.
-#   Without this, the build script won't run from the crontab:
-#
-#    export PATH="$HOME/.platformio/penv/bin:$PATH" 
-#
-# The crontab contains:
-#  0 2 * * * cd ~/meshtastic/github/meshtastic && source "~/.bashrc"; ./build-nightly.sh > ~/cronout.txt 2> ~/cronout.txt
-
-cd Meshtastic-device
-
-git pull
-
-bin/build-all.sh
-
-date_stamp=$(date +'%Y-%m-%d')
-
-cd ..
-
-# TODO: Archive the same binaries used by the build-all script.
-#zip -r meshtastic_device_nightly_${date_stamp} Meshtastic-device/release/latest/bins
-cp Meshtastic-device/release/archive/`ls -t ./Meshtastic-device/release/archive/| head -1` meshtastic_device_nightly_${date_stamp}.zip
-
-# Copy the file to the webserver
-scp meshtastic_device_nightly_${date_stamp}.zip jm@10.11.12.20:/volume1/web/meshtastic/nightly_builds/
-
-# Delete the local copy
-rm meshtastic_device_nightly_${date_stamp}.zip

bin/device-install.sh

@@ -46,10 +46,10 @@ shift "$((OPTIND-1))"
 
 if [ -f "${FILENAME}" ]; then
 	echo "Trying to flash ${FILENAME}, but first erasing and writing system information"
-	$PYTHON -m esptool --baud 921600 erase_flash
-	$PYTHON -m esptool --baud 921600 write_flash 0x1000 system-info.bin
-	$PYTHON -m esptool --baud 921600 write_flash 0x00390000 spiffs-*.bin
-	$PYTHON -m esptool --baud 921600 write_flash 0x10000 ${FILENAME}
+	$PYTHON -m esptool  erase_flash
+	$PYTHON -m esptool  write_flash 0x1000 system-info.bin
+	$PYTHON -m esptool  write_flash 0x00390000 spiffs-*.bin
+	$PYTHON -m esptool  write_flash 0x10000 ${FILENAME}
 else
 	echo "Invalid file: ${FILENAME}"
 	show_help

geeksville-private/TODO.md

@@ -325,7 +325,7 @@ Items after the first final candidate release.
 - add "store and forward" support for messages, or move to the DB sync model. This would allow messages to be eventually delivered even if nodes are out of contact at the moment.
 - use variable length Strings in protobufs (instead of current fixed buffers). This would save lots of RAM
 - use BLEDevice::setPower to lower our BLE transmit power - extra range doesn't help us, it costs amps and it increases snoopability
-- make a HAM build: just a new frequency list, a bool to say 'never do encryption' and use hte callsign as that node's unique id. -from Girts
+- make a Ham build: just a new frequency list, a bool to say 'never do encryption' and use the callsign as that node's unique id. -from Girts
 - don't forward redundant pings or ping responses to the phone, it just wastes phone battery
 - don't send location packets if we haven't moved significantly
 - scrub default radio config settings for bandwidth/range/speed

platformio.ini

@@ -9,7 +9,7 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-;default_envs = tbeam
+default_envs = tbeam
 ;default_envs = tbeam0.7
 ;default_envs = heltec-v2.0
 ;default_envs = tlora-v1
@@ -21,7 +21,7 @@
 ;default_envs = native # lora-relay-v1 # nrf52840dk-geeksville # linux # or if you'd like to change the default to something like lora-relay-v1 put that here
 ;default_envs = rak4631
 ;default_envs = rak4630
-default_envs = meshtastic-diy-v1
+;default_envs = meshtastic-diy-v1
 
 [common]
 ; common is not currently used
@@ -113,14 +113,18 @@ lib_deps =
   adafruit/Adafruit Unified Sensor@^1.1.4
   paulstoffregen/OneWire@^2.3.5
   robtillaart/DS18B20@^0.1.11
+  h2zero/NimBLE-Arduino@1.3.1
 # Hmm - this doesn't work yet
 # board_build.ldscript = linker/esp32.extram.bss.ld
-lib_ignore = segger_rtt
+lib_ignore = 
+  segger_rtt
+  ESP32 BLE Arduino
+
 platform_packages =
     framework-arduinoespressif32@https://github.com/meshtastic/arduino-esp32.git#4cde0f5d412d2695184f32e8a47e9bea57b45276
 
 ; leave this commented out to avoid breaking Windows
-upload_port = /dev/ttyUSB0
+;upload_port = /dev/ttyUSB0
 ;monitor_port = /dev/ttyUSB0
 
 ;upload_port = /dev/cu.SLAB_USBtoUART

src/airtime.cpp

@@ -1,117 +1,135 @@
-#include "configuration.h"
 #include "airtime.h"
 #include "NodeDB.h"
+#include "configuration.h"
 
-#define periodsToLog 24
 
 AirTime *airTime;
 
-uint32_t secondsPerPeriod = 3600;
-uint32_t lastMillis = 0;
-uint32_t secSinceBoot = 0;
-
-// AirTime at;
-
 // Don't read out of this directly. Use the helper functions.
-struct airtimeStruct {
-    uint32_t periodTX[periodsToLog];     // AirTime transmitted
-    uint32_t periodRX[periodsToLog];     // AirTime received and repeated (Only valid mesh packets)
-    uint32_t periodRX_ALL[periodsToLog]; // AirTime received regardless of valid mesh packet. Could include noise.
-    uint8_t lastPeriodIndex;
-} airtimes;
+
 
 void AirTime::logAirtime(reportTypes reportType, uint32_t airtime_ms)
 {
+
+    // TODO: Is the airtimes array still necessary? It's now in myNodeInfo anyway
+
     if (reportType == TX_LOG) {
         DEBUG_MSG("AirTime - Packet transmitted : %ums\n", airtime_ms);
-        airtimes.periodTX[0] = airtimes.periodTX[0] + airtime_ms;
+        this->airtimes.periodTX[0] = this->airtimes.periodTX[0] + airtime_ms;
         myNodeInfo.air_period_tx[0] = myNodeInfo.air_period_tx[0] + airtime_ms;
     } else if (reportType == RX_LOG) {
         DEBUG_MSG("AirTime - Packet received : %ums\n", airtime_ms);
-        airtimes.periodRX[0] = airtimes.periodRX[0] + airtime_ms;
+        this->airtimes.periodRX[0] = this->airtimes.periodRX[0] + airtime_ms;
         myNodeInfo.air_period_rx[0] = myNodeInfo.air_period_rx[0] + airtime_ms;
     } else if (reportType == RX_ALL_LOG) {
         DEBUG_MSG("AirTime - Packet received (noise?) : %ums\n", airtime_ms);
-        airtimes.periodRX_ALL[0] = airtimes.periodRX_ALL[0] + airtime_ms;
-    } else {
-        DEBUG_MSG("AirTime - Unknown report time. This should never happen!!\n");
+        this->airtimes.periodRX_ALL[0] = this->airtimes.periodRX_ALL[0] + airtime_ms;
     }
+
+    uint8_t channelUtilPeriod = (getSecondsSinceBoot() / 10) % CHANNEL_UTILIZATION_PERIODS;
+    this->channelUtilization[channelUtilPeriod] = channelUtilization[channelUtilPeriod] + airtime_ms;
 }
 
-uint8_t currentPeriodIndex()
+uint8_t AirTime::currentPeriodIndex()
 {
-    return ((getSecondsSinceBoot() / secondsPerPeriod) % periodsToLog);
+    return ((getSecondsSinceBoot() / SECONDS_PER_PERIOD) % PERIODS_TO_LOG);
 }
 
-void airtimeRotatePeriod()
+void AirTime::airtimeRotatePeriod()
 {
 
-    if (airtimes.lastPeriodIndex != currentPeriodIndex()) {
+    if (this->airtimes.lastPeriodIndex != currentPeriodIndex()) {
         DEBUG_MSG("Rotating airtimes to a new period = %u\n", currentPeriodIndex());
 
-        for (int i = periodsToLog - 2; i >= 0; --i) {
-            airtimes.periodTX[i + 1] = airtimes.periodTX[i];
-            airtimes.periodRX[i + 1] = airtimes.periodRX[i];
-            airtimes.periodRX_ALL[i + 1] = airtimes.periodRX_ALL[i];
+        for (int i = PERIODS_TO_LOG - 2; i >= 0; --i) {
+            this->airtimes.periodTX[i + 1] = this->airtimes.periodTX[i];
+            this->airtimes.periodRX[i + 1] = this->airtimes.periodRX[i];
+            this->airtimes.periodRX_ALL[i + 1] = this->airtimes.periodRX_ALL[i];
 
             myNodeInfo.air_period_tx[i + 1] = myNodeInfo.air_period_tx[i];
             myNodeInfo.air_period_rx[i + 1] = myNodeInfo.air_period_rx[i];
         }
-        airtimes.periodTX[0] = 0;
-        airtimes.periodRX[0] = 0;
-        airtimes.periodRX_ALL[0] = 0;
+        
+        this->airtimes.periodTX[0] = 0;
+        this->airtimes.periodRX[0] = 0;
+        this->airtimes.periodRX_ALL[0] = 0;
 
         myNodeInfo.air_period_tx[0] = 0;
         myNodeInfo.air_period_rx[0] = 0;
 
-
-        airtimes.lastPeriodIndex = currentPeriodIndex();
+        this->airtimes.lastPeriodIndex = currentPeriodIndex();
     }
 }
 
-uint32_t *airtimeReport(reportTypes reportType)
+uint32_t *AirTime::airtimeReport(reportTypes reportType)
 {
 
     if (reportType == TX_LOG) {
-        return airtimes.periodTX;
+        return this->airtimes.periodTX;
     } else if (reportType == RX_LOG) {
-        return airtimes.periodRX;
+        return this->airtimes.periodRX;
     } else if (reportType == RX_ALL_LOG) {
-        return airtimes.periodRX_ALL;
+        return this->airtimes.periodRX_ALL;
     }
     return 0;
 }
 
-uint8_t getPeriodsToLog()
+uint8_t AirTime::getPeriodsToLog()
 {
-    return periodsToLog;
+    return PERIODS_TO_LOG;
 }
 
-uint32_t getSecondsPerPeriod()
+uint32_t AirTime::getSecondsPerPeriod()
 {
-    return secondsPerPeriod;
+    return SECONDS_PER_PERIOD;
 }
 
-uint32_t getSecondsSinceBoot()
+uint32_t AirTime::getSecondsSinceBoot()
 {
-    return secSinceBoot;
+    return this->secSinceBoot;
+}
+
+float AirTime::channelUtilizationPercent()
+{
+    uint32_t sum = 0;
+    for (uint32_t i = 0; i < CHANNEL_UTILIZATION_PERIODS; i++) {
+        sum += this->channelUtilization[i];
+        // DEBUG_MSG("ChanUtilArray %u %u\n", i, this->channelUtilization[i]);
+    }
+
+    return (float(sum) / float(CHANNEL_UTILIZATION_PERIODS * 10 * 1000)) * 100;
 }
 
 AirTime::AirTime() : concurrency::OSThread("AirTime") {}
 
 int32_t AirTime::runOnce()
 {
-    //DEBUG_MSG("AirTime::runOnce()\n");
-
-    airtimeRotatePeriod();
     secSinceBoot++;
 
-    /*
-        This actually doesn't need to be run once per second but we currently use it for the
-        secSinceBoot counter.
+    uint8_t utilPeriod = (getSecondsSinceBoot() / 10) % CHANNEL_UTILIZATION_PERIODS;
+
+    if (firstTime) {
+        airtimeRotatePeriod();
+
+        for (uint32_t i = 0; i < CHANNEL_UTILIZATION_PERIODS; i++) {
+            this->channelUtilization[i] = 0;
+        }
+
+        firstTime = false;
+        lastUtilPeriod = utilPeriod;
+
+    } else {
+
+        // Reset the channelUtilization window when we roll over
+        if (lastUtilPeriod != utilPeriod) {
+            lastUtilPeriod = utilPeriod;
+
+            this->channelUtilization[utilPeriod] = 0;
+        }
+
+        // Update channel_utilization every second.
+        myNodeInfo.channel_utilization = airTime->channelUtilizationPercent();
+    }
 
-        If we have a better counter of how long the device has been online (and not millis())
-        then we can change this to something less frequent. Maybe once ever 5 seconds?
-    */
     return (1000 * 1);
 }

src/airtime.h

@@ -23,21 +23,18 @@
 
   RX_ALL_LOG - RX_LOG = Other lora radios on our frequency channel.
 */
+
+#define CHANNEL_UTILIZATION_PERIODS 6
+#define SECONDS_PER_PERIOD 3600
+#define PERIODS_TO_LOG 24
+
+
 enum reportTypes { TX_LOG, RX_LOG, RX_ALL_LOG };
 
 void logAirtime(reportTypes reportType, uint32_t airtime_ms);
 
-void airtimeRotatePeriod();
-
-uint8_t currentPeriodIndex();
-uint8_t getPeriodsToLog();
-
-uint32_t getSecondsSinceBoot();
-
 uint32_t *airtimeReport(reportTypes reportType);
 
-uint32_t getSecondsPerPeriod();
-
 class AirTime : private concurrency::OSThread
 {
 
@@ -45,6 +42,27 @@ class AirTime : private concurrency::OSThread
     AirTime();
 
     void logAirtime(reportTypes reportType, uint32_t airtime_ms);
+    float channelUtilizationPercent();
+    uint32_t channelUtilization[CHANNEL_UTILIZATION_PERIODS];
+
+    uint8_t currentPeriodIndex();
+    void airtimeRotatePeriod();
+    uint8_t getPeriodsToLog();
+    uint32_t getSecondsPerPeriod();
+    uint32_t getSecondsSinceBoot();
+    uint32_t *airtimeReport(reportTypes reportType);
+
+  private:
+    bool firstTime = true;
+    uint8_t lastUtilPeriod = 0;
+    uint32_t secSinceBoot = 0;
+
+    struct airtimeStruct {
+        uint32_t periodTX[PERIODS_TO_LOG];     // AirTime transmitted
+        uint32_t periodRX[PERIODS_TO_LOG];     // AirTime received and repeated (Only valid mesh packets)
+        uint32_t periodRX_ALL[PERIODS_TO_LOG]; // AirTime received regardless of valid mesh packet. Could include noise.
+        uint8_t lastPeriodIndex;
+    } airtimes;
 
   protected:
     virtual int32_t runOnce() override;

src/configuration.h

@@ -243,6 +243,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //#define GPS_TX_PIN 12 // not connected
 
 #define BUTTON_PIN 39 // The middle button GPIO on the T-Beam
+#define EXT_NOTIFY_OUT 12 // Overridden default pin to use for Ext Notify Plugin (#975).
 
 #define LORA_DIO0 26  // a No connect on the SX1262/SX1268 module
 #define LORA_RESET 23 // RST for SX1276, and for SX1262/SX1268

src/graphics/Screen.cpp

@@ -27,18 +27,19 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "NodeDB.h"
 #include "Screen.h"
 #include "fonts.h"
+#include "gps/GeoCoord.h"
 #include "gps/RTC.h"
 #include "graphics/images.h"
 #include "main.h"
 #include "mesh-pb-constants.h"
 #include "mesh/Channels.h"
 #include "plugins/TextMessagePlugin.h"
+#include "sleep.h"
 #include "target_specific.h"
 #include "utils.h"
-#include "gps/GeoCoord.h"
-#include "sleep.h"
 
 #ifndef NO_ESP32
+#include "esp_task_wdt.h"
 #include "mesh/http/WiFiAPClient.h"
 #endif
 
@@ -155,6 +156,11 @@ static void drawSSLScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     display->setFont(FONT_SMALL);
     display->drawString(64 + x, y, "Creating SSL certificate");
 
+#ifndef NO_ESP32
+    yield();
+    esp_task_wdt_reset();
+#endif
+
     display->setFont(FONT_SMALL);
     if ((millis() / 1000) % 2) {
         display->drawString(64 + x, FONT_HEIGHT_SMALL + y + 2, "Please wait . . .");
@@ -247,10 +253,10 @@ static void drawCriticalFaultFrame(OLEDDisplay *display, OLEDDisplayUiState *sta
 }
 
 // Ignore messages orginating from phone (from the current node 0x0) unless range test or store and forward plugin are enabled
-static bool shouldDrawMessage(const MeshPacket *packet) {
-    return packet->from != 0 &&
-        !radioConfig.preferences.range_test_plugin_enabled &&
-        !radioConfig.preferences.store_forward_plugin_enabled;
+static bool shouldDrawMessage(const MeshPacket *packet)
+{
+    return packet->from != 0 && !radioConfig.preferences.range_test_plugin_enabled &&
+           !radioConfig.preferences.store_forward_plugin_enabled;
 }
 
 /// Draw the last text message we received
@@ -429,6 +435,7 @@ static void drawGPScoordinates(OLEDDisplay *display, int16_t x, int16_t y, const
         displayLine = "No GPS Lock";
         display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(displayLine))) / 2, y, displayLine);
     } else {
+
         if (gpsFormat != GpsCoordinateFormat_GpsFormatDMS) {
             char coordinateLine[22];
             geoCoord.updateCoords(int32_t(gps->getLatitude()), int32_t(gps->getLongitude()), int32_t(gps->getAltitude()));
@@ -438,25 +445,36 @@ static void drawGPScoordinates(OLEDDisplay *display, int16_t x, int16_t y, const
                 sprintf(coordinateLine, "%2i%1c %06i %07i", geoCoord.getUTMZone(), geoCoord.getUTMBand(),
                         geoCoord.getUTMEasting(), geoCoord.getUTMNorthing());
             } else if (gpsFormat == GpsCoordinateFormat_GpsFormatMGRS) { // Military Grid Reference System
-                sprintf(coordinateLine, "%2i%1c %1c%1c %05i %05i", geoCoord.getMGRSZone(), geoCoord.getMGRSBand(), geoCoord.getMGRSEast100k(),
-                        geoCoord.getMGRSNorth100k(), geoCoord.getMGRSEasting(), geoCoord.getMGRSNorthing());
+                sprintf(coordinateLine, "%2i%1c %1c%1c %05i %05i", geoCoord.getMGRSZone(), geoCoord.getMGRSBand(),
+                        geoCoord.getMGRSEast100k(), geoCoord.getMGRSNorth100k(), geoCoord.getMGRSEasting(),
+                        geoCoord.getMGRSNorthing());
             } else if (gpsFormat == GpsCoordinateFormat_GpsFormatOLC) { // Open Location Code
                 geoCoord.getOLCCode(coordinateLine);
-            } else if (gpsFormat == GpsCoordinateFormat_GpsFormatOSGR) { // Ordnance Survey Grid Reference
+            } else if (gpsFormat == GpsCoordinateFormat_GpsFormatOSGR) {              // Ordnance Survey Grid Reference
                 if (geoCoord.getOSGRE100k() == 'I' || geoCoord.getOSGRN100k() == 'I') // OSGR is only valid around the UK region
                     sprintf(coordinateLine, "%s", "Out of Boundary");
                 else
-                    sprintf(coordinateLine, "%1c%1c %05i %05i", geoCoord.getOSGRE100k(),geoCoord.getOSGRN100k(), 
+                    sprintf(coordinateLine, "%1c%1c %05i %05i", geoCoord.getOSGRE100k(), geoCoord.getOSGRN100k(),
                             geoCoord.getOSGREasting(), geoCoord.getOSGRNorthing());
             }
-            
-            display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(coordinateLine))) / 2, y, coordinateLine);
+
+            // If fixed position, display text "Fixed GPS" alternating with the coordinates.
+            if (radioConfig.preferences.fixed_position) {
+                if ((millis() / 10000) % 2) {
+                    display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(coordinateLine))) / 2, y, coordinateLine);
+                } else {
+                    display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth("Fixed GPS"))) / 2, y, "Fixed GPS");
+                }
+            } else {
+                display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(coordinateLine))) / 2, y, coordinateLine);
+            }
+
         } else {
             char latLine[22];
             char lonLine[22];
             sprintf(latLine, "%2i° %2i' %2.4f\" %1c", geoCoord.getDMSLatDeg(), geoCoord.getDMSLatMin(), geoCoord.getDMSLatSec(),
                     geoCoord.getDMSLatCP());
-            sprintf(lonLine, "%3i° %2i' %2.4f\" %1c", geoCoord.getDMSLonDeg(), geoCoord.getDMSLonMin(), geoCoord.getDMSLonSec(), 
+            sprintf(lonLine, "%3i° %2i' %2.4f\" %1c", geoCoord.getDMSLonDeg(), geoCoord.getDMSLonMin(), geoCoord.getDMSLonSec(),
                     geoCoord.getDMSLonCP());
             display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(latLine))) / 2, y - FONT_HEIGHT_SMALL * 1, latLine);
             display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(lonLine))) / 2, y, lonLine);
@@ -601,11 +619,6 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
             n = nodeDB.getNodeByIndex(nodeIndex);
         }
         displayedNodeNum = n->num;
-
-        // We just changed to a new node screen, ask that node for updated state if it's older than 2 minutes
-        if (sinceLastSeen(n) > 120) {
-            service.sendNetworkPing(displayedNodeNum, true);
-        }
     }
 
     NodeInfo *node = nodeDB.getNodeByIndex(nodeIndex);
@@ -648,7 +661,8 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
             // display direction toward node
             hasNodeHeading = true;
             Position &p = node->position;
-            float d = GeoCoord::latLongToMeter(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
+            float d =
+                GeoCoord::latLongToMeter(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
             if (d < 2000)
                 snprintf(distStr, sizeof(distStr), "%.0f m", d);
             else
@@ -656,7 +670,8 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
 
             // FIXME, also keep the guess at the operators heading and add/substract
             // it.  currently we don't do this and instead draw north up only.
-            float bearingToOther = GeoCoord::bearing(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
+            float bearingToOther =
+                GeoCoord::bearing(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
             headingRadian = bearingToOther - myHeading;
             drawNodeHeading(display, compassX, compassY, headingRadian);
         }
@@ -697,6 +712,7 @@ void _screen_header()
 
 Screen::Screen(uint8_t address, int sda, int scl) : OSThread("Screen"), cmdQueue(32), dispdev(address, sda, scl), ui(&dispdev)
 {
+    address_found = address;
     cmdQueue.setReader(this);
 }
 
@@ -897,13 +913,13 @@ int32_t Screen::runOnce()
     // standard screen switching is stopped.
     if (showingNormalScreen) {
         // standard screen loop handling here
-        if (radioConfig.preferences.auto_screen_carousel_secs > 0 && 
+        if (radioConfig.preferences.auto_screen_carousel_secs > 0 &&
             (millis() - lastScreenTransition) > (radioConfig.preferences.auto_screen_carousel_secs * 1000)) {
             DEBUG_MSG("LastScreenTransition exceeded %ums transitioning to next frame\n", (millis() - lastScreenTransition));
             handleOnPress();
         }
     }
-    
+
     // DEBUG_MSG("want fps %d, fixed=%d\n", targetFramerate,
     // ui.getUiState()->frameState); If we are scrolling we need to be called
     // soon, otherwise just 1 fps (to save CPU) We also ask to be called twice
@@ -934,10 +950,12 @@ void Screen::drawDebugInfoWiFiTrampoline(OLEDDisplay *display, OLEDDisplayUiStat
  * it is expected that this will be used during the boot phase */
 void Screen::setSSLFrames()
 {
-    DEBUG_MSG("showing SSL frames\n");
-    static FrameCallback sslFrames[] = {drawSSLScreen};
-    ui.setFrames(sslFrames, 1);
-    ui.update();
+    if (address_found) {
+        // DEBUG_MSG("showing SSL frames\n");
+        static FrameCallback sslFrames[] = {drawSSLScreen};
+        ui.setFrames(sslFrames, 1);
+        ui.update();
+    }
 }
 
 // restore our regular frame list
@@ -1067,7 +1085,7 @@ void Screen::handlePrint(const char *text)
 }
 
 void Screen::handleOnPress()
-{  
+{
     // If screen was off, just wake it, otherwise advance to next frame
     // If we are in a transition, the press must have bounced, drop it.
     if (ui.getUiState()->frameState == FIXED) {
@@ -1184,7 +1202,7 @@ void DebugInfo::drawFrameWiFi(OLEDDisplay *display, OLEDDisplayUiState *state, i
         if (radioConfig.preferences.wifi_ap_mode || isSoftAPForced()) {
             display->drawString(x, y + FONT_HEIGHT_SMALL * 1, "IP: " + String(WiFi.softAPIP().toString().c_str()));
 
-            // Number of connections to the AP. Default mmax for the esp32 is 4
+            // Number of connections to the AP. Default max for the esp32 is 4
             display->drawString(x + SCREEN_WIDTH - display->getStringWidth("(" + String(WiFi.softAPgetStationNum()) + "/4)"),
                                 y + FONT_HEIGHT_SMALL * 1, "(" + String(WiFi.softAPgetStationNum()) + "/4)");
         } else {
@@ -1380,11 +1398,11 @@ void DebugInfo::drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *stat
 
     display->drawString(x, y + FONT_HEIGHT_SMALL * 1, uptime);
 
-#ifndef NO_ESP32
-    // Show CPU Frequency.
-    display->drawString(x + SCREEN_WIDTH - display->getStringWidth("CPU " + String(getCpuFrequencyMhz()) + "MHz"),
-                        y + FONT_HEIGHT_SMALL * 1, "CPU " + String(getCpuFrequencyMhz()) + "MHz");
-#endif
+    // Display Channel Utilization
+    char chUtil[13];
+    sprintf(chUtil, "ChUtil %2.0f%%", airTime->channelUtilizationPercent());
+    display->drawString(x + SCREEN_WIDTH - display->getStringWidth(chUtil),
+                        y + FONT_HEIGHT_SMALL * 1, chUtil);
 
     // Line 3
     if (radioConfig.preferences.gps_format != GpsCoordinateFormat_GpsFormatDMS) // if DMS then don't draw altitude
@@ -1430,7 +1448,8 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
     return 0;
 }
 
-int Screen::handleTextMessage(const MeshPacket *packet) {
+int Screen::handleTextMessage(const MeshPacket *packet)
+{
     if (showingNormalScreen) {
         setFrames(); // Regen the list of screens (will show new text message)
     }

src/graphics/Screen.h

@@ -97,6 +97,8 @@ class Screen : public concurrency::OSThread
     Screen(const Screen &) = delete;
     Screen &operator=(const Screen &) = delete;
 
+    uint8_t address_found;
+
     /// Initializes the UI, turns on the display, starts showing boot screen.
     //
     // Not thread safe - must be called before any other methods are called.

src/main.cpp

@@ -282,6 +282,8 @@ class ButtonThread : public OSThread
     {
 #ifndef NO_ESP32
         disablePin();
+#elif defined(HAS_EINK)
+        digitalWrite(PIN_EINK_EN,digitalRead(PIN_EINK_EN) == LOW);
 #endif
     }
 
@@ -606,6 +608,7 @@ void setup()
                     ) * 1000;
     DEBUG_MSG("myNodeInfo.bitrate = %f bytes / sec\n", myNodeInfo.bitrate);
 
+
     // This must be _after_ service.init because we need our preferences loaded from flash to have proper timeout values
     PowerFSM_setup(); // we will transition to ON in a couple of seconds, FIXME, only do this for cold boots, not waking from SDS
     powerFSMthread = new PowerFSMThread();

src/mesh/ReliableRouter.cpp

@@ -16,8 +16,13 @@ ErrorCode ReliableRouter::send(MeshPacket *p)
         // If someone asks for acks on broadcast, we need the hop limit to be at least one, so that first node that receives our
         // message will rebroadcast.  But asking for hop_limit 0 in that context means the client app has no preference on hop counts
         // and we want this message to get through the whole mesh, so use the default.
-        if (p->to == NODENUM_BROADCAST && p->hop_limit == 0)
-            p->hop_limit = HOP_RELIABLE;
+        if (p->to == NODENUM_BROADCAST && p->hop_limit == 0) {
+            if (radioConfig.preferences.hop_limit && radioConfig.preferences.hop_limit <= HOP_MAX) {
+                p->hop_limit = (radioConfig.preferences.hop_limit >= HOP_MAX) ? HOP_MAX : radioConfig.preferences.hop_limit;
+            } else {
+                p->hop_limit = HOP_RELIABLE;
+            }
+        }
 
         auto copy = packetPool.allocCopy(*p);
         startRetransmission(copy);

src/mesh/Router.cpp

@@ -115,7 +115,11 @@ MeshPacket *Router::allocForSending()
     p->which_payloadVariant = MeshPacket_decoded_tag; // Assume payload is decoded at start.
     p->from = nodeDB.getNodeNum();
     p->to = NODENUM_BROADCAST;
-    p->hop_limit = HOP_RELIABLE;
+    if (radioConfig.preferences.hop_limit && radioConfig.preferences.hop_limit <= HOP_MAX) {
+        p->hop_limit = (radioConfig.preferences.hop_limit >= HOP_MAX) ? HOP_MAX : radioConfig.preferences.hop_limit;
+    } else {
+        p->hop_limit = HOP_RELIABLE;
+    }
     p->id = generatePacketId();
     p->rx_time =
         getValidTime(RTCQualityFromNet); // Just in case we process the packet locally - make sure it has a valid timestamp

src/mesh/generated/admin.pb.h

@@ -86,7 +86,7 @@ extern const pb_msgdesc_t AdminMessage_msg;
 #define AdminMessage_fields &AdminMessage_msg
 
 /* Maximum encoded size of messages (where known) */
-#define AdminMessage_size                        454
+#define AdminMessage_size                        529
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/deviceonly.pb.h

@@ -125,7 +125,7 @@ extern const pb_msgdesc_t ChannelFile_msg;
 /* Maximum encoded size of messages (where known) */
 #define LegacyRadioConfig_size                   4
 #define LegacyRadioConfig_LegacyPreferences_size 2
-#define DeviceState_size                         9939
+#define DeviceState_size                         9967
 #define ChannelFile_size                         832
 
 #ifdef __cplusplus

src/mesh/generated/mesh.pb.c

@@ -52,3 +52,4 @@ PB_BIND(ToRadio_PeerInfo, ToRadio_PeerInfo, AUTO)
 
 
 
+

src/mesh/generated/mesh.pb.h

@@ -110,6 +110,12 @@ typedef enum _MeshPacket_Priority {
     MeshPacket_Priority_MAX = 127
 } MeshPacket_Priority;
 
+typedef enum _MeshPacket_Delayed {
+    MeshPacket_Delayed_NO_DELAY = 0,
+    MeshPacket_Delayed_DELAYED_BROADCAST = 1,
+    MeshPacket_Delayed_DELAYED_DIRECT = 2
+} MeshPacket_Delayed;
+
 typedef enum _LogRecord_Level {
     LogRecord_Level_UNSET = 0,
     LogRecord_Level_CRITICAL = 50,
@@ -158,6 +164,7 @@ typedef struct _MyNodeInfo {
     pb_size_t air_period_rx_count;
     uint32_t air_period_rx[24];
     bool has_wifi;
+    float channel_utilization;
 } MyNodeInfo;
 
 typedef struct _Position {
@@ -226,6 +233,9 @@ typedef struct _MeshPacket {
     bool want_ack;
     MeshPacket_Priority priority;
     int32_t rx_rssi;
+    MeshPacket_Delayed delayed;
+    uint32_t reply_id;
+    bool is_tapback;
 } MeshPacket;
 
 typedef struct _NodeInfo {
@@ -304,6 +314,10 @@ typedef struct _ToRadio {
 #define _MeshPacket_Priority_MAX MeshPacket_Priority_MAX
 #define _MeshPacket_Priority_ARRAYSIZE ((MeshPacket_Priority)(MeshPacket_Priority_MAX+1))
 
+#define _MeshPacket_Delayed_MIN MeshPacket_Delayed_NO_DELAY
+#define _MeshPacket_Delayed_MAX MeshPacket_Delayed_DELAYED_DIRECT
+#define _MeshPacket_Delayed_ARRAYSIZE ((MeshPacket_Delayed)(MeshPacket_Delayed_DELAYED_DIRECT+1))
+
 #define _LogRecord_Level_MIN LogRecord_Level_UNSET
 #define _LogRecord_Level_MAX LogRecord_Level_CRITICAL
 #define _LogRecord_Level_ARRAYSIZE ((LogRecord_Level)(LogRecord_Level_CRITICAL+1))
@@ -319,9 +333,9 @@ extern "C" {
 #define RouteDiscovery_init_default              {0, {0, 0, 0, 0, 0, 0, 0, 0}}
 #define Routing_init_default                     {0, {RouteDiscovery_init_default}}
 #define Data_init_default                        {_PortNum_MIN, {0, {0}}, 0, 0, 0, 0}
-#define MeshPacket_init_default                  {0, 0, 0, 0, {Data_init_default}, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN, 0}
+#define MeshPacket_init_default                  {0, 0, 0, 0, {Data_init_default}, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN, 0, _MeshPacket_Delayed_MIN, 0, 0}
 #define NodeInfo_init_default                    {0, false, User_init_default, false, Position_init_default, 0, 0}
-#define MyNodeInfo_init_default                  {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0}
+#define MyNodeInfo_init_default                  {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 0}
 #define LogRecord_init_default                   {"", 0, "", _LogRecord_Level_MIN}
 #define FromRadio_init_default                   {0, 0, {MyNodeInfo_init_default}}
 #define ToRadio_init_default                     {0, {MeshPacket_init_default}}
@@ -331,9 +345,9 @@ extern "C" {
 #define RouteDiscovery_init_zero                 {0, {0, 0, 0, 0, 0, 0, 0, 0}}
 #define Routing_init_zero                        {0, {RouteDiscovery_init_zero}}
 #define Data_init_zero                           {_PortNum_MIN, {0, {0}}, 0, 0, 0, 0}
-#define MeshPacket_init_zero                     {0, 0, 0, 0, {Data_init_zero}, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN, 0}
+#define MeshPacket_init_zero                     {0, 0, 0, 0, {Data_init_zero}, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN, 0, _MeshPacket_Delayed_MIN, 0, 0}
 #define NodeInfo_init_zero                       {0, false, User_init_zero, false, Position_init_zero, 0, 0}
-#define MyNodeInfo_init_zero                     {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0}
+#define MyNodeInfo_init_zero                     {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 0}
 #define LogRecord_init_zero                      {"", 0, "", _LogRecord_Level_MIN}
 #define FromRadio_init_zero                      {0, 0, {MyNodeInfo_init_zero}}
 #define ToRadio_init_zero                        {0, {MeshPacket_init_zero}}
@@ -367,6 +381,7 @@ extern "C" {
 #define MyNodeInfo_air_period_tx_tag             16
 #define MyNodeInfo_air_period_rx_tag             17
 #define MyNodeInfo_has_wifi_tag                  18
+#define MyNodeInfo_channel_utilization_tag       19
 #define Position_latitude_i_tag                  1
 #define Position_longitude_i_tag                 2
 #define Position_altitude_tag                    3
@@ -415,6 +430,9 @@ extern "C" {
 #define MeshPacket_want_ack_tag                  11
 #define MeshPacket_priority_tag                  12
 #define MeshPacket_rx_rssi_tag                   13
+#define MeshPacket_delayed_tag                   15
+#define MeshPacket_reply_id_tag                  16
+#define MeshPacket_is_tapback_tag                17
 #define NodeInfo_num_tag                         1
 #define NodeInfo_user_tag                        2
 #define NodeInfo_position_tag                    3
@@ -513,7 +531,10 @@ X(a, STATIC,   SINGULAR, FLOAT,    rx_snr,            8) \
 X(a, STATIC,   SINGULAR, UINT32,   hop_limit,        10) \
 X(a, STATIC,   SINGULAR, BOOL,     want_ack,         11) \
 X(a, STATIC,   SINGULAR, UENUM,    priority,         12) \
-X(a, STATIC,   SINGULAR, INT32,    rx_rssi,          13)
+X(a, STATIC,   SINGULAR, INT32,    rx_rssi,          13) \
+X(a, STATIC,   SINGULAR, UENUM,    delayed,          15) \
+X(a, STATIC,   SINGULAR, FIXED32,  reply_id,         16) \
+X(a, STATIC,   SINGULAR, BOOL,     is_tapback,       17)
 #define MeshPacket_CALLBACK NULL
 #define MeshPacket_DEFAULT NULL
 #define MeshPacket_payloadVariant_decoded_MSGTYPE Data
@@ -546,7 +567,8 @@ X(a, STATIC,   SINGULAR, UINT32,   min_app_version,  14) \
 X(a, STATIC,   SINGULAR, UINT32,   max_channels,     15) \
 X(a, STATIC,   REPEATED, UINT32,   air_period_tx,    16) \
 X(a, STATIC,   REPEATED, UINT32,   air_period_rx,    17) \
-X(a, STATIC,   SINGULAR, BOOL,     has_wifi,         18)
+X(a, STATIC,   SINGULAR, BOOL,     has_wifi,         18) \
+X(a, STATIC,   SINGULAR, FLOAT,    channel_utilization,  19)
 #define MyNodeInfo_CALLBACK NULL
 #define MyNodeInfo_DEFAULT NULL
 
@@ -622,12 +644,12 @@ extern const pb_msgdesc_t ToRadio_PeerInfo_msg;
 #define RouteDiscovery_size                      40
 #define Routing_size                             42
 #define Data_size                                260
-#define MeshPacket_size                          309
+#define MeshPacket_size                          320
 #define NodeInfo_size                            270
-#define MyNodeInfo_size                          445
+#define MyNodeInfo_size                          451
 #define LogRecord_size                           81
-#define FromRadio_size                           454
-#define ToRadio_size                             312
+#define FromRadio_size                           460
+#define ToRadio_size                             323
 #define ToRadio_PeerInfo_size                    8
 
 #ifdef __cplusplus

src/mesh/generated/radioconfig.pb.h

@@ -152,6 +152,9 @@ typedef struct _RadioConfig_UserPreferences {
     bool is_always_powered;
     uint32_t auto_screen_carousel_secs;
     uint32_t on_battery_shutdown_after_secs;
+    uint32_t hop_limit;
+    char mqtt_username[32];
+    char mqtt_password[32];
 } RadioConfig_UserPreferences;
 
 typedef struct _RadioConfig {
@@ -196,9 +199,9 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define RadioConfig_init_default                 {false, RadioConfig_UserPreferences_init_default}
-#define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, 0, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, _GpsCoordinateFormat_MIN, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0, 0, 0, 0, 0, 0}
+#define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, 0, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, _GpsCoordinateFormat_MIN, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0, 0, 0, 0, 0, 0, 0, "", ""}
 #define RadioConfig_init_zero                    {false, RadioConfig_UserPreferences_init_zero}
-#define RadioConfig_UserPreferences_init_zero    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, 0, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, _GpsCoordinateFormat_MIN, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0, 0, 0, 0, 0, 0}
+#define RadioConfig_UserPreferences_init_zero    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, 0, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, _GpsCoordinateFormat_MIN, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0, 0, 0, 0, 0, 0, 0, "", ""}
 
 /* Field tags (for use in manual encoding/decoding) */
 #define RadioConfig_UserPreferences_position_broadcast_secs_tag 1
@@ -266,6 +269,9 @@ extern "C" {
 #define RadioConfig_UserPreferences_is_always_powered_tag 151
 #define RadioConfig_UserPreferences_auto_screen_carousel_secs_tag 152
 #define RadioConfig_UserPreferences_on_battery_shutdown_after_secs_tag 153
+#define RadioConfig_UserPreferences_hop_limit_tag 154
+#define RadioConfig_UserPreferences_mqtt_username_tag 155
+#define RadioConfig_UserPreferences_mqtt_password_tag 156
 #define RadioConfig_preferences_tag              1
 
 /* Struct field encoding specification for nanopb */
@@ -340,7 +346,10 @@ X(a, STATIC,   SINGULAR, BOOL,     store_forward_plugin_heartbeat, 149) \
 X(a, STATIC,   SINGULAR, UINT32,   position_flags,  150) \
 X(a, STATIC,   SINGULAR, BOOL,     is_always_powered, 151) \
 X(a, STATIC,   SINGULAR, UINT32,   auto_screen_carousel_secs, 152) \
-X(a, STATIC,   SINGULAR, UINT32,   on_battery_shutdown_after_secs, 153)
+X(a, STATIC,   SINGULAR, UINT32,   on_battery_shutdown_after_secs, 153) \
+X(a, STATIC,   SINGULAR, UINT32,   hop_limit,       154) \
+X(a, STATIC,   SINGULAR, STRING,   mqtt_username,   155) \
+X(a, STATIC,   SINGULAR, STRING,   mqtt_password,   156)
 #define RadioConfig_UserPreferences_CALLBACK NULL
 #define RadioConfig_UserPreferences_DEFAULT NULL
 
@@ -352,8 +361,8 @@ extern const pb_msgdesc_t RadioConfig_UserPreferences_msg;
 #define RadioConfig_UserPreferences_fields &RadioConfig_UserPreferences_msg
 
 /* Maximum encoded size of messages (where known) */
-#define RadioConfig_size                         451
-#define RadioConfig_UserPreferences_size         448
+#define RadioConfig_size                         526
+#define RadioConfig_UserPreferences_size         523
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/http/ContentHandler.cpp

@@ -53,19 +53,6 @@ char contentTypes[][2][32] = {{".txt", "text/plain"},     {".html", "text/html"}
 // Our API to handle messages to and from the radio.
 HttpAPI webAPI;
 
-uint32_t numberOfRequests = 0;
-uint32_t timeSpeedUp = 0;
-
-uint32_t getTimeSpeedUp()
-{
-    return timeSpeedUp;
-}
-
-void setTimeSpeedUp()
-{
-    timeSpeedUp = millis();
-}
-
 void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
 {
 
@@ -87,7 +74,7 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     ResourceNode *nodeJsonReport = new ResourceNode("/json/report", "GET", &handleReport);
     ResourceNode *nodeJsonSpiffsBrowseStatic = new ResourceNode("/json/spiffs/browse/static", "GET", &handleSpiffsBrowseStatic);
     ResourceNode *nodeJsonDelete = new ResourceNode("/json/spiffs/delete/static", "DELETE", &handleSpiffsDeleteStatic);
-    
+
     ResourceNode *nodeRoot = new ResourceNode("/*", "GET", &handleStatic);
 
     // Secure nodes
@@ -105,8 +92,6 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     secureServer->registerNode(nodeJsonReport);
     secureServer->registerNode(nodeRoot);
 
-    secureServer->addMiddleware(&middlewareSpeedUp240);
-
     // Insecure nodes
     insecureServer->registerNode(nodeAPIv1ToRadioOptions);
     insecureServer->registerNode(nodeAPIv1ToRadio);
@@ -121,43 +106,6 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     insecureServer->registerNode(nodeJsonDelete);
     insecureServer->registerNode(nodeJsonReport);
     insecureServer->registerNode(nodeRoot);
-
-    insecureServer->addMiddleware(&middlewareSpeedUp160);
-}
-
-void middlewareSpeedUp240(HTTPRequest *req, HTTPResponse *res, std::function<void()> next)
-{
-    // We want to print the response status, so we need to call next() first.
-    next();
-
-    // Phone (or other device) has contacted us over WiFi. Keep the radio turned on.
-    //   TODO: This should go into its own middleware layer separate from the speedup.
-    powerFSM.trigger(EVENT_CONTACT_FROM_PHONE);
-
-    setCpuFrequencyMhz(240);
-    setTimeSpeedUp();
-
-    numberOfRequests++;
-}
-
-void middlewareSpeedUp160(HTTPRequest *req, HTTPResponse *res, std::function<void()> next)
-{
-    // We want to print the response status, so we need to call next() first.
-    next();
-
-    // Phone (or other device) has contacted us over WiFi. Keep the radio turned on.
-    //   TODO: This should go into its own middleware layer separate from the speedup.
-    powerFSM.trigger(EVENT_CONTACT_FROM_PHONE);
-
-    // If the frequency is 240mhz, we have recently gotten a HTTPS request.
-    //   In that case, leave the frequency where it is and just update the
-    //   countdown timer (timeSpeedUp).
-    if (getCpuFrequencyMhz() != 240) {
-        setCpuFrequencyMhz(160);
-    }
-    setTimeSpeedUp();
-
-    numberOfRequests++;
 }
 
 void handleAPIv1FromRadio(HTTPRequest *req, HTTPResponse *res)
@@ -227,7 +175,6 @@ void handleAPIv1ToRadio(HTTPRequest *req, HTTPResponse *res)
     res->setHeader("Access-Control-Allow-Methods", "PUT, OPTIONS");
     res->setHeader("X-Protobuf-Schema", "https://raw.githubusercontent.com/meshtastic/Meshtastic-protobufs/master/mesh.proto");
 
-
     if (req->getMethod() == "OPTIONS") {
         res->setStatusCode(204); // Success with no content
         // res->print(""); @todo remove
@@ -336,7 +283,6 @@ void handleStatic(HTTPRequest *req, HTTPResponse *res)
         std::string filename = "/static/" + parameter1;
         std::string filenameGzip = "/static/" + parameter1 + ".gz";
 
-
         // Try to open the file from SPIFFS
         File file;
 
@@ -403,10 +349,6 @@ void handleFormUpload(HTTPRequest *req, HTTPResponse *res)
     DEBUG_MSG("Form Upload - Disabling keep-alive\n");
     res->setHeader("Connection", "close");
 
-    DEBUG_MSG("Form Upload - Set frequency to 240mhz\n");
-    // The upload process is very CPU intensive. Let's speed things up a bit.
-    setCpuFrequencyMhz(240);
-
     // First, we need to check the encoding of the form that we have received.
     // The browser will set the Content-Type request header, so we can use it for that purpose.
     // Then we select the body parser based on the encoding.
@@ -560,12 +502,12 @@ void handleReport(HTTPRequest *req, HTTPResponse *res)
 
     res->print("\"tx_log\": [");
 
-    logArray = airtimeReport(TX_LOG);
-    for (int i = 0; i < getPeriodsToLog(); i++) {
+    logArray = airTime->airtimeReport(TX_LOG);
+    for (int i = 0; i < airTime->getPeriodsToLog(); i++) {
         uint32_t tmp;
         tmp = *(logArray + i);
         res->printf("%d", tmp);
-        if (i != getPeriodsToLog() - 1) {
+        if (i != airTime->getPeriodsToLog() - 1) {
             res->print(", ");
         }
     }
@@ -573,12 +515,12 @@ void handleReport(HTTPRequest *req, HTTPResponse *res)
     res->println("],");
     res->print("\"rx_log\": [");
 
-    logArray = airtimeReport(RX_LOG);
-    for (int i = 0; i < getPeriodsToLog(); i++) {
+    logArray = airTime->airtimeReport(RX_LOG);
+    for (int i = 0; i < airTime->getPeriodsToLog(); i++) {
         uint32_t tmp;
         tmp = *(logArray + i);
         res->printf("%d", tmp);
-        if (i != getPeriodsToLog() - 1) {
+        if (i != airTime->getPeriodsToLog() - 1) {
             res->print(", ");
         }
     }
@@ -586,26 +528,25 @@ void handleReport(HTTPRequest *req, HTTPResponse *res)
     res->println("],");
     res->print("\"rx_all_log\": [");
 
-    logArray = airtimeReport(RX_ALL_LOG);
-    for (int i = 0; i < getPeriodsToLog(); i++) {
+    logArray = airTime->airtimeReport(RX_ALL_LOG);
+    for (int i = 0; i < airTime->getPeriodsToLog(); i++) {
         uint32_t tmp;
         tmp = *(logArray + i);
         res->printf("%d", tmp);
-        if (i != getPeriodsToLog() - 1) {
+        if (i != airTime->getPeriodsToLog() - 1) {
             res->print(", ");
         }
     }
 
     res->println("],");
-    res->printf("\"seconds_since_boot\": %u,\n", getSecondsSinceBoot());
-    res->printf("\"seconds_per_period\": %u,\n", getSecondsPerPeriod());
-    res->printf("\"periods_to_log\": %u\n", getPeriodsToLog());
+    res->printf("\"seconds_since_boot\": %u,\n", airTime->getSecondsSinceBoot());
+    res->printf("\"seconds_per_period\": %u,\n", airTime->getSecondsPerPeriod());
+    res->printf("\"periods_to_log\": %u\n", airTime->getPeriodsToLog());
 
     res->println("},");
 
     res->println("\"wifi\": {");
 
-    res->printf("\"web_request_count\": %d,\n", numberOfRequests);
     res->println("\"rssi\": " + String(WiFi.RSSI()) + ",");
 
     if (radioConfig.preferences.wifi_ap_mode || isSoftAPForced()) {
@@ -736,15 +677,11 @@ void handleScanNetworks(HTTPRequest *req, HTTPResponse *res)
         for (int i = 0; i < n; ++i) {
             char ssidArray[50];
             String ssidString = String(WiFi.SSID(i));
-            // String ssidString = String(WiFi.SSID(i)).toCharArray(ssidArray, WiFi.SSID(i).length());
             ssidString.replace("\"", "\\\"");
             ssidString.toCharArray(ssidArray, 50);
 
             if (WiFi.encryptionType(i) != WIFI_AUTH_OPEN) {
-                // res->println("{\"ssid\": \"%s\",\"rssi\": -75}, ", String(WiFi.SSID(i).c_str() );
-
                 res->printf("{\"ssid\": \"%s\",\"rssi\": %d}", ssidArray, WiFi.RSSI(i));
-                // WiFi.RSSI(i)
                 if (i != n - 1) {
                     res->printf(",");
                 }

src/mesh/http/ContentHandler.h

@@ -18,10 +18,6 @@ void handleReport(HTTPRequest *req, HTTPResponse *res);
 void middlewareSpeedUp240(HTTPRequest *req, HTTPResponse *res, std::function<void()> next);
 void middlewareSpeedUp160(HTTPRequest *req, HTTPResponse *res, std::function<void()> next);
 
-uint32_t getTimeSpeedUp();
-void setTimeSpeedUp();
-
-
 // Interface to the PhoneAPI to access the protobufs with messages
 class HttpAPI : public PhoneAPI
 {

src/mesh/http/ContentHelper.h

@@ -3,6 +3,4 @@
 
 #define BoolToString(x) ((x) ? "true" : "false")
 
-
 void replaceAll(std::string &str, const std::string &from, const std::string &to);
-

src/mesh/http/WebServer.cpp

@@ -1,11 +1,12 @@
-#include "main.h"
 #include "mesh/http/WebServer.h"
 #include "NodeDB.h"
+#include "graphics/Screen.h"
+#include "main.h"
 #include "mesh/http/WiFiAPClient.h"
+#include "sleep.h"
 #include <HTTPBodyParser.hpp>
 #include <HTTPMultipartBodyParser.hpp>
 #include <HTTPURLEncodedBodyParser.hpp>
-#include "sleep.h"
 
 #include <WebServer.h>
 #include <WiFi.h>
@@ -58,20 +59,10 @@ static void handleWebResponse()
             // will be ignored by the NRF boards.
             handleDNSResponse();
 
-            if(secureServer)
+            if (secureServer)
                 secureServer->loop();
             insecureServer->loop();
         }
-
-        /*
-            Slow down the CPU if we have not received a request within the last few
-            seconds.
-        */
-
-        if (millis() - getTimeSpeedUp() >= (25 * 1000)) {
-            setCpuFrequencyMhz(80);
-            setTimeSpeedUp();
-        }
     }
 }
 
@@ -79,16 +70,14 @@ static void taskCreateCert(void *parameter)
 {
     prefs.begin("MeshtasticHTTPS", false);
 
-    // Delete the saved certs (used in debugging)
-
 #if 0
-        DEBUG_MSG("Deleting any saved SSL keys ...\n");
-        // prefs.clear();
-        prefs.remove("PK");
-        prefs.remove("cert");
+    // Delete the saved certs (used in debugging)
+    DEBUG_MSG("Deleting any saved SSL keys ...\n");
+    // prefs.clear();
+    prefs.remove("PK");
+    prefs.remove("cert");
 #endif
 
-
     DEBUG_MSG("Checking if we have a previously saved SSL Certificate.\n");
 
     size_t pkLen = prefs.getBytesLength("PK");
@@ -110,8 +99,6 @@ static void taskCreateCert(void *parameter)
 
     } else {
 
-        setCPUFast(true);
-
         DEBUG_MSG("Creating the certificate. This may take a while. Please wait...\n");
         yield();
         cert = new SSLCert();
@@ -123,29 +110,16 @@ static void taskCreateCert(void *parameter)
         if (createCertResult != 0) {
             DEBUG_MSG("Creating the certificate failed\n");
 
-            // Serial.printf("Creating the certificate failed. Error Code = 0x%02X, check SSLCert.hpp for details",
-            //              createCertResult);
-            // while (true)
-            //    delay(500);
         } else {
             DEBUG_MSG("Creating the certificate was successful\n");
 
             DEBUG_MSG("Created Private Key: %d Bytes\n", cert->getPKLength());
-            // for (int i = 0; i < cert->getPKLength(); i++)
-            //  Serial.print(cert->getPKData()[i], HEX);
-            // Serial.println();
 
             DEBUG_MSG("Created Certificate: %d Bytes\n", cert->getCertLength());
-            // for (int i = 0; i < cert->getCertLength(); i++)
-            //  Serial.print(cert->getCertData()[i], HEX);
-            // Serial.println();
 
             prefs.putBytes("PK", (uint8_t *)cert->getPKData(), cert->getPKLength());
             prefs.putBytes("cert", (uint8_t *)cert->getCertData(), cert->getCertLength());
         }
-
-        setCPUFast(false);
-
     }
 
     isCertReady = true;
@@ -156,6 +130,7 @@ static void taskCreateCert(void *parameter)
 
 void createSSLCert()
 {
+    bool runLoop = false;
     if (isWifiAvailable() && !isCertReady) {
 
         // Create a new process just to handle creating the cert.
@@ -163,21 +138,28 @@ void createSSLCert()
         //  jm@casler.org (Oct 2020)
         xTaskCreate(taskCreateCert, /* Task function. */
                     "createCert",   /* String with name of task. */
-                    16384,          /* Stack size in bytes. */
-                    NULL,           /* Parameter passed as input of the task */
-                    16,             /* Priority of the task. */
-                    NULL);          /* Task handle. */
+                    // 16384,          /* Stack size in bytes. */
+                    8192,  /* Stack size in bytes. */
+                    NULL,  /* Parameter passed as input of the task */
+                    16,    /* Priority of the task. */
+                    NULL); /* Task handle. */
 
         DEBUG_MSG("Waiting for SSL Cert to be generated.\n");
-        int seconds = 0;
         while (!isCertReady) {
-            DEBUG_MSG(".");
-            delay(1000);
-            yield();
-            esp_task_wdt_reset();
-            seconds++;
-            if ((seconds == 3) && screen) {
-                screen->setSSLFrames();
+            if ((millis() / 500) % 2) {
+                if (runLoop) {
+                    DEBUG_MSG(".");
+
+                    yield();
+                    esp_task_wdt_reset();
+
+                    if (millis() / 1000 >= 3) {
+                        screen->setSSLFrames();
+                    }
+                }
+                runLoop = false;
+            } else {
+                runLoop = true;
             }
         }
         DEBUG_MSG("SSL Cert Ready!\n");
@@ -201,51 +183,17 @@ void initWebServer()
 {
     DEBUG_MSG("Initializing Web Server ...\n");
 
-#if 0
-// this seems to be a copypaste dup of taskCreateCert
-    prefs.begin("MeshtasticHTTPS", false);
-
-    size_t pkLen = prefs.getBytesLength("PK");
-    size_t certLen = prefs.getBytesLength("cert");
-
-    DEBUG_MSG("Checking if we have a previously saved SSL Certificate.\n");
-
-    if (pkLen && certLen) {
-
-        uint8_t *pkBuffer = new uint8_t[pkLen];
-        prefs.getBytes("PK", pkBuffer, pkLen);
-
-        uint8_t *certBuffer = new uint8_t[certLen];
-        prefs.getBytes("cert", certBuffer, certLen);
-
-        cert = new SSLCert(certBuffer, certLen, pkBuffer, pkLen);
-
-        DEBUG_MSG("Retrieved Private Key: %d Bytes\n", cert->getPKLength());
-        // DEBUG_MSG("Retrieved Private Key: " + String(cert->getPKLength()) + " Bytes");
-        // for (int i = 0; i < cert->getPKLength(); i++)
-        //  Serial.print(cert->getPKData()[i], HEX);
-        // Serial.println();
-
-        DEBUG_MSG("Retrieved Certificate: %d Bytes\n", cert->getCertLength());
-        // for (int i = 0; i < cert->getCertLength(); i++)
-        //  Serial.print(cert->getCertData()[i], HEX);
-        // Serial.println();
-    } else {
-        DEBUG_MSG("Web Server started without SSL keys! How did this happen?\n");
-    }
-#endif
-
     // We can now use the new certificate to setup our server as usual.
     secureServer = new HTTPSServer(cert);
     insecureServer = new HTTPServer();
 
     registerHandlers(insecureServer, secureServer);
 
-    if(secureServer) {
+    if (secureServer) {
         DEBUG_MSG("Starting Secure Web Server...\n");
         secureServer->start();
     }
-    DEBUG_MSG("Starting Insecure Web Server...\n");    
+    DEBUG_MSG("Starting Insecure Web Server...\n");
     insecureServer->start();
     if (insecureServer->isRunning()) {
         DEBUG_MSG("Web Servers Ready! :-) \n");

src/mesh/http/WebServer.h

@@ -15,7 +15,6 @@ class WebServerThread : private concurrency::OSThread
     WebServerThread();
 
   protected:
-
     virtual int32_t runOnce();
 };
 

src/mesh/http/WiFiAPClient.cpp

@@ -103,6 +103,8 @@ void deinitWifi()
         saving on the 2.4g transceiver.
     */
 
+    DEBUG_MSG("WiFi deinit\n");
+
     if (isWifiAvailable()) {
         WiFi.mode(WIFI_MODE_NULL);
         DEBUG_MSG("WiFi Turned Off\n");
@@ -140,6 +142,14 @@ static void onNetworkConnected()
 // Startup WiFi
 bool initWifi(bool forceSoftAP)
 {
+    if (forceSoftAP) {
+        DEBUG_MSG("WiFi ... Forced AP Mode\n");
+    } else if (radioConfig.preferences.wifi_ap_mode) {
+        DEBUG_MSG("WiFi ... AP Mode\n");
+    } else {
+        DEBUG_MSG("WiFi ... Client Mode\n");
+    }
+
     forcedSoftAP = forceSoftAP;
 
     if ((radioConfig.has_preferences && radioConfig.preferences.wifi_ssid[0]) || forceSoftAP) {
@@ -152,30 +162,28 @@ bool initWifi(bool forceSoftAP)
             wifiPsw = NULL;
 
         if (*wifiName || forceSoftAP) {
-            if (forceSoftAP) {
-
-                DEBUG_MSG("Forcing SoftAP\n");
-
-                const char *softAPssid = "meshtasticAdmin";
-                const char *softAPpasswd = "12345678";
+            if (radioConfig.preferences.wifi_ap_mode || forceSoftAP) {
 
                 IPAddress apIP(192, 168, 42, 1);
                 WiFi.onEvent(WiFiEvent);
+                WiFi.mode(WIFI_AP);
+
+                if (forcedSoftAP) {
+                    const char *softAPssid = "meshtasticAdmin";
+                    const char *softAPpasswd = "12345678";
+
+                    DEBUG_MSG("Starting (Forced) WIFI AP: ssid=%s, ok=%d\n", softAPssid, WiFi.softAP(softAPssid, softAPpasswd));
+
+                } else {
+                    DEBUG_MSG("Starting WIFI AP: ssid=%s, ok=%d\n", wifiName, WiFi.softAP(wifiName, wifiPsw));
+
+                }
 
                 WiFi.softAPConfig(apIP, apIP, IPAddress(255, 255, 255, 0));
-                DEBUG_MSG("STARTING WIFI AP: ssid=%s, ok=%d\n", softAPssid, WiFi.softAP(softAPssid, softAPpasswd));
-                DEBUG_MSG("MY IP ADDRESS: %s\n", WiFi.softAPIP().toString().c_str());
+                DEBUG_MSG("MY IP AP ADDRESS: %s\n", WiFi.softAPIP().toString().c_str());
 
-                dnsServer.start(53, "*", apIP);
-
-            } else if (radioConfig.preferences.wifi_ap_mode) {
-
-                IPAddress apIP(192, 168, 42, 1);
-                WiFi.onEvent(WiFiEvent);
-
-                WiFi.softAPConfig(apIP, apIP, IPAddress(255, 255, 255, 0));
-                DEBUG_MSG("STARTING WIFI AP: ssid=%s, ok=%d\n", wifiName, WiFi.softAP(wifiName, wifiPsw));
-                DEBUG_MSG("MY IP ADDRESS: %s\n", WiFi.softAPIP().toString().c_str());
+                // This is needed to improve performance.
+                esp_wifi_set_ps(WIFI_PS_NONE); // Disable radio power saving
 
                 dnsServer.start(53, "*", apIP);
 
@@ -184,14 +192,13 @@ bool initWifi(bool forceSoftAP)
                 getMacAddr(dmac);
                 sprintf(ourHost, "Meshtastic-%02x%02x", dmac[4], dmac[5]);
 
-                Serial.println(ourHost);
-
                 WiFi.mode(WIFI_MODE_STA);
                 WiFi.setHostname(ourHost);
                 WiFi.onEvent(WiFiEvent);
-                // esp_wifi_set_ps(WIFI_PS_NONE); // Disable power saving
 
-                // WiFiEventId_t eventID = WiFi.onEvent(
+                // This is needed to improve performance.
+                esp_wifi_set_ps(WIFI_PS_NONE); // Disable radio power saving
+
                 WiFi.onEvent(
                     [](WiFiEvent_t event, WiFiEventInfo_t info) {
                         Serial.print("\nWiFi lost connection. Reason: ");
@@ -250,7 +257,7 @@ static void WiFiEvent(WiFiEvent_t event)
         DEBUG_MSG("Authentication mode of access point has changed\n");
         break;
     case SYSTEM_EVENT_STA_GOT_IP:
-        DEBUG_MSG("Obtained IP address: \n");
+        DEBUG_MSG("Obtained IP address: ");
         Serial.println(WiFi.localIP());
         onNetworkConnected();
         break;
@@ -271,7 +278,7 @@ static void WiFiEvent(WiFiEvent_t event)
         break;
     case SYSTEM_EVENT_AP_START:
         DEBUG_MSG("WiFi access point started\n");
-        //Serial.println(WiFi.softAPIP());
+
         onNetworkConnected();
         break;
     case SYSTEM_EVENT_AP_STOP:
@@ -305,7 +312,7 @@ static void WiFiEvent(WiFiEvent_t event)
         DEBUG_MSG("Ethernet disconnected\n");
         break;
     case SYSTEM_EVENT_ETH_GOT_IP:
-        DEBUG_MSG("Obtained IP address\n");
+        DEBUG_MSG("Obtained IP address (SYSTEM_EVENT_ETH_GOT_IP)\n");
         break;
     default:
         break;
@@ -314,7 +321,7 @@ static void WiFiEvent(WiFiEvent_t event)
 
 void handleDNSResponse()
 {
-    if (radioConfig.preferences.wifi_ap_mode) {
+    if (radioConfig.preferences.wifi_ap_mode || isSoftAPForced()) {
         dnsServer.processNextRequest();
     }
 }

src/mesh/http/WiFiAPClient.h

@@ -21,4 +21,3 @@ void handleDNSResponse();
 bool isSoftAPForced();
 
 uint8_t getWifiDisconnectReason();
-

src/mqtt/MQTT.cpp

@@ -68,9 +68,22 @@ void MQTT::reconnect()
     if (wantsLink()) {
         const char *serverAddr = "mqtt.meshtastic.org"; // default hostname
         int serverPort = 1883;                          // default server port
+        const char *mqttUsername = "meshdev";
+        const char *mqttPassword = "large4cats";
 
-        if (*radioConfig.preferences.mqtt_server)
+        if (*radioConfig.preferences.mqtt_server) {
             serverAddr = radioConfig.preferences.mqtt_server; // Override the default
+            mqttUsername = radioConfig.preferences.mqtt_username; //do not use the hardcoded credentials for a custom mqtt server
+            mqttPassword = radioConfig.preferences.mqtt_password;
+        } else {
+            //we are using the default server.  Use the hardcoded credentials by default, but allow overriding
+            if (*radioConfig.preferences.mqtt_username && radioConfig.preferences.mqtt_username[0] != '\0') {
+                mqttUsername = radioConfig.preferences.mqtt_username;
+            }
+            if (*radioConfig.preferences.mqtt_password && radioConfig.preferences.mqtt_password[0] != '\0') {
+                mqttPassword = radioConfig.preferences.mqtt_password;
+            }
+        }
 
         String server = String(serverAddr);
         int delimIndex = server.indexOf(':');
@@ -82,9 +95,9 @@ void MQTT::reconnect()
         }
         pubSub.setServer(serverAddr, serverPort);
 
-        DEBUG_MSG("Connecting to MQTT server %s, port: %d\n", serverAddr, serverPort);
+        DEBUG_MSG("Connecting to MQTT server %s, port: %d, username: %s, password %s\n", serverAddr, serverPort, mqttUsername, mqttPassword);
         auto myStatus = (statusTopic + owner.id);
-        bool connected = pubSub.connect(owner.id, "meshdev", "large4cats", myStatus.c_str(), 1, true, "offline");
+        bool connected = pubSub.connect(owner.id, mqttUsername, mqttPassword, myStatus.c_str(), 1, true, "offline");
         if (connected) {
             DEBUG_MSG("MQTT connected\n");
             enabled = true; // Start running background process again

src/nimble/BluetoothUtil.cpp

@@ -11,7 +11,6 @@
 #include "services/gap/ble_svc_gap.h"
 #include "services/gatt/ble_svc_gatt.h"
 #include "sleep.h"
-#include <Arduino.h>
 #include <WiFi.h>
 
 #ifndef NO_ESP32
@@ -557,7 +556,7 @@ void setBluetoothEnable(bool on)
 
         bluetoothOn = on;
         if (on) {
-            if (!initWifi(isSoftAPForced())) // if we are using wifi, don't turn on bluetooth also
+            if (! isWifiAvailable()  )
             {
                 Serial.printf("Pre BT: %u heap size\n", ESP.getFreeHeap());
                 // ESP_ERROR_CHECK( heap_trace_start(HEAP_TRACE_LEAKS) );

src/nimble/BluetoothUtil.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <Arduino.h>
 #include <functional>
 
 /// We only allow one BLE connection at a time

src/nimble/NimbleBluetoothAPI.cpp

@@ -3,7 +3,6 @@
 #include "configuration.h"
 #include "nimble/BluetoothUtil.h"
 #include "nimble/NimbleDefs.h"
-#include <Arduino.h>
 
 // This scratch buffer is used for various bluetooth reads/writes - but it is safe because only one bt operation can be in
 // proccess at once

src/nimble/NimbleDefs.h

@@ -11,7 +11,6 @@
 #include "host/ble_uuid.h"
 #include "nimble/nimble_port.h"
 #include "nimble/nimble_port_freertos.h"
-#include <Arduino.h>
 
 #ifdef __cplusplus
 extern "C" {

src/nrf52/main-nrf52.cpp

@@ -38,18 +38,13 @@ void __attribute__((noreturn)) __assert_func(const char *file, int line, const c
 
 void getMacAddr(uint8_t *dmac)
 {
-    ble_gap_addr_t addr;
-    if (sd_ble_gap_addr_get(&addr) == NRF_SUCCESS) {
-        memcpy(dmac, addr.addr, 6);
-    } else { 
-        const uint8_t *src = (const uint8_t *)NRF_FICR->DEVICEADDR;
-        dmac[5] = src[0];
-        dmac[4] = src[1];
-        dmac[3] = src[2];
-        dmac[2] = src[3];
-        dmac[1] = src[4];
-        dmac[0] = src[5] | 0xc0; // MSB high two bits get set elsewhere in the bluetooth stack
-    }
+    const uint8_t *src = (const uint8_t *)NRF_FICR->DEVICEADDR;
+    dmac[5] = src[0];
+    dmac[4] = src[1];
+    dmac[3] = src[2];
+    dmac[2] = src[3];
+    dmac[1] = src[4];
+    dmac[0] = src[5] | 0xc0; // MSB high two bits get set elsewhere in the bluetooth stack
 }
 
 static void initBrownout()

src/plugins/PositionPlugin.cpp

@@ -127,7 +127,7 @@ int32_t PositionPlugin::runOnce()
 {
     NodeInfo *node = nodeDB.getNode(nodeDB.getNodeNum());
 
-    radioConfig.preferences.position_broadcast_smart = true;
+    //radioConfig.preferences.position_broadcast_smart = true;
 
     // We limit our GPS broadcasts to a max rate
     uint32_t now = millis();

src/plugins/esp32/StoreForwardPlugin.cpp

@@ -38,9 +38,8 @@ int32_t StoreForwardPlugin::runOnce()
                     this->packetHistoryTXQueue_index++;
                 }
             }
+            DEBUG_MSG("SF myNodeInfo.bitrate = %f bytes / sec\n", myNodeInfo.bitrate);
 
-            // TODO: Dynamicly adjust the time this returns in the loop based on the size of the packets being actually
-            // transmitted.
             return (this->packetTimeMax);
         } else {
             DEBUG_MSG("Store & Forward Plugin - Disabled (is_router = false)\n");
@@ -81,8 +80,7 @@ void StoreForwardPlugin::populatePSRAM()
     /* Use a maximum of 2/3 the available PSRAM unless otherwise specified.
         Note: This needs to be done after every thing that would use PSRAM
     */
-    uint32_t numberOfPackets =
-        (this->records ? this->records : (((ESP.getFreePsram() / 3) * 2) / sizeof(PacketHistoryStruct)));
+    uint32_t numberOfPackets = (this->records ? this->records : (((ESP.getFreePsram() / 3) * 2) / sizeof(PacketHistoryStruct)));
 
     this->packetHistory = static_cast<PacketHistoryStruct *>(ps_calloc(numberOfPackets, sizeof(PacketHistoryStruct)));
 
@@ -108,7 +106,7 @@ void StoreForwardPlugin::historyReport()
 void StoreForwardPlugin::historySend(uint32_t msAgo, uint32_t to)
 {
 
-    //uint32_t packetsSent = 0;
+    // uint32_t packetsSent = 0;
 
     uint32_t queueSize = storeForwardPlugin->historyQueueCreate(msAgo, to);
 
@@ -145,13 +143,16 @@ uint32_t StoreForwardPlugin::historyQueueCreate(uint32_t msAgo, uint32_t to)
                 Copy the messages that were received by the router in the last msAgo
                 to the packetHistoryTXQueue structure.
 
-                TODO: The condition (this->packetHistory[i].to & 0xffffffff) == to) is not tested since
+                TODO: The condition (this->packetHistory[i].to & NODENUM_BROADCAST) == to) is not tested since
                 I don't have an easy way to target a specific user. Will need to do this soon.
             */
-            if ((this->packetHistory[i].to & 0xffffffff) == 0xffffffff || ((this->packetHistory[i].to & 0xffffffff) == to)) {
+            if ((this->packetHistory[i].to & NODENUM_BROADCAST) == NODENUM_BROADCAST ||
+                ((this->packetHistory[i].to & NODENUM_BROADCAST) == to)) {
+                this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].time = this->packetHistory[i].time;
                 this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].time = this->packetHistory[i].time;
                 this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].to = this->packetHistory[i].to;
                 this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].from = this->packetHistory[i].from;
+                this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].channel = this->packetHistory[i].channel;
                 this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].payload_size = this->packetHistory[i].payload_size;
                 memcpy(this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].payload, this->packetHistory[i].payload,
                        Constants_DATA_PAYLOAD_LEN);
@@ -172,6 +173,7 @@ void StoreForwardPlugin::historyAdd(const MeshPacket &mp)
 
     this->packetHistory[this->packetHistoryCurrent].time = millis();
     this->packetHistory[this->packetHistoryCurrent].to = mp.to;
+    this->packetHistory[this->packetHistoryCurrent].channel = mp.channel;
     this->packetHistory[this->packetHistoryCurrent].from = mp.from;
     this->packetHistory[this->packetHistoryCurrent].payload_size = p.payload.size;
     memcpy(this->packetHistory[this->packetHistoryCurrent].payload, p.payload.bytes, Constants_DATA_PAYLOAD_LEN);
@@ -192,6 +194,7 @@ void StoreForwardPlugin::sendPayload(NodeNum dest, uint32_t packetHistory_index)
 
     p->to = dest;
     p->from = this->packetHistoryTXQueue[packetHistory_index].from;
+    p->channel = this->packetHistoryTXQueue[packetHistory_index].channel;
 
     // Let's assume that if the router received the S&F request that the client is in range.
     //   TODO: Make this configurable.
@@ -211,6 +214,10 @@ void StoreForwardPlugin::sendMessage(NodeNum dest, char *str)
 
     p->to = dest;
 
+    // FIXME - Determine if the delayed packet is broadcast or delayed. For now, assume
+    //  everything is broadcast.
+    p->delayed = MeshPacket_Delayed_DELAYED_BROADCAST;
+
     // Let's assume that if the router received the S&F request that the client is in range.
     //   TODO: Make this configurable.
     p->want_ack = false;
@@ -352,7 +359,6 @@ ProcessMessage StoreForwardPlugin::handleReceivedProtobuf(const MeshPacket &mp,
         DEBUG_MSG("StoreAndForward_RequestResponse_ROUTER_PONG\n");
         break;
 
-
     default:
         assert(0); // unexpected state - FIXME, make an error code and reboot
     }
@@ -408,13 +414,8 @@ StoreForwardPlugin::StoreForwardPlugin()
                     // Popupate PSRAM with our data structures.
                     this->populatePSRAM();
 
-                    // Calculate the packet time.
-                    // this->packetTimeMax = RadioLibInterface::instance->getPacketTime(Constants_DATA_PAYLOAD_LEN);
-                    // RadioLibInterface::instance->getPacketTime(Constants_DATA_PAYLOAD_LEN);
-                    // RadioLibInterface::instance->getPacketTime(Constants_DATA_PAYLOAD_LEN);
-                    // RadioInterface::getPacketTime(500)l
-
-                    this->packetTimeMax = 2000;
+                    // this->packetTimeMax = 2000;
+                    // DEBUG_MSG("SF Time to Transmit maxPacketSize (%d bytes) %d ms\n", maxPacketSize, this->packetTimeMax);
 
                 } else {
                     DEBUG_MSG("Device has less than 1M of PSRAM free. Aborting startup.\n");

src/plugins/esp32/StoreForwardPlugin.h

@@ -12,6 +12,7 @@ struct PacketHistoryStruct {
     uint32_t time;
     uint32_t to;
     uint32_t from;
+    uint8_t channel;
     bool ack;
     uint8_t payload[Constants_DATA_PAYLOAD_LEN];
     pb_size_t payload_size;
@@ -33,7 +34,7 @@ class StoreForwardPlugin : public SinglePortPlugin, private concurrency::OSThrea
     uint32_t packetHistoryTXQueue_size;
     uint32_t packetHistoryTXQueue_index = 0;
 
-    uint32_t packetTimeMax = 0;
+    uint32_t packetTimeMax = 2000;
 
   public:
     StoreForwardPlugin();

src/sleep.cpp

@@ -14,6 +14,7 @@
 #include "rom/rtc.h"
 #include <driver/rtc_io.h>
 #include <driver/uart.h>
+#include "mesh/http/WiFiAPClient.h"
 
 #include "nimble/BluetoothUtil.h"
 
@@ -48,6 +49,22 @@ RTC_DATA_ATTR int bootCount = 0;
 void setCPUFast(bool on)
 {
 #ifndef NO_ESP32
+
+    if (isWifiAvailable()) {
+        /* 
+        * 
+        * There's a newly introduced bug in the espressif framework where WiFi is 
+        *   unstable when the frequency is less than 240mhz.
+        * 
+        *   This mostly impacts WiFi AP mode but we'll bump the frequency for
+        *     all WiFi use cases.
+        * (Added: Dec 23, 2021 by Jm Casler)
+        */
+        DEBUG_MSG("Setting CPU to 240mhz because WiFi is in use.\n");
+        setCpuFrequencyMhz(240);
+        return;
+    }
+
     setCpuFrequencyMhz(on ? 240 : 80);
 #endif
 }

version.properties

@@ -1,4 +1,4 @@
 [VERSION]  
 major = 1  
 minor = 2
-build = 49
+build = 50