[create-pull-request] automated change (#2316)

Co-authored-by: thebentern <thebentern@users.noreply.github.com>

.github/workflows/main_matrix.yml

@@ -73,6 +73,7 @@ jobs:
           - board: m5stack-coreink
           - board: tbeam-s3-core
           - board: tlora-t3s3-v1
+          - board: nano-g1-explorer
     uses: ./.github/workflows/build_esp32.yml
     with:
       board: ${{ matrix.board }}
@@ -92,16 +93,16 @@ jobs:
     with:
       board: ${{ matrix.board }}
 
-  build-rpi2040:
-    strategy:
-      fail-fast: false
-      max-parallel: 2
-      matrix:
-        include:
-          - board: pico
-    uses: ./.github/workflows/build_rpi2040.yml
-    with:
-      board: ${{ matrix.board }}
+  # build-rpi2040:
+  #   strategy:
+  #     fail-fast: false
+  #     max-parallel: 2
+  #     matrix:
+  #       include:
+  #         - board: pico
+  #   uses: ./.github/workflows/build_rpi2040.yml
+  #   with:
+  #     board: ${{ matrix.board }}
 
   build-native:
     runs-on: ubuntu-latest
@@ -175,7 +176,7 @@ jobs:
 
   gather-artifacts:
     runs-on: ubuntu-latest
-    needs: [build-esp32, build-nrf52, build-native, build-rpi2040]
+    needs: [build-esp32, build-nrf52, build-native] #, build-rpi2040]
     steps:
       - name: Checkout code
         uses: actions/checkout@v3

arch/esp32/esp32.ini

@@ -1,7 +1,7 @@
 ; Common settings for ESP targes, mixin with extends = esp32_base
 [esp32_base]
 extends = arduino_base
-platform = platformio/espressif32@^5.2.0
+platform = platformio/espressif32@^6.0.0
 build_src_filter = 
   ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2040> -<mesh/eth/>
 upload_speed = 921600
@@ -26,7 +26,7 @@ build_flags =
   -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
   -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
   -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
-  -DDEBUG_HEAP
+  ;-DDEBUG_HEAP
 
 lib_deps =
   ${arduino_base.lib_deps}

arch/esp32/esp32s2.ini

@@ -1,6 +1,6 @@
 [esp32s2_base]
 extends = arduino_base
-platform = platformio/espressif32@^5.2.0
+platform = platformio/espressif32@^6.0.0
 build_src_filter = 
   ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2040> -<mesh/eth/> -<nimble/>
 upload_speed = 961200
@@ -27,7 +27,7 @@ build_flags =
   -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
   -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
   -DHAS_BLUETOOTH=0
-  -DDEBUG_HEAP
+  ;-DDEBUG_HEAP
   
 lib_deps =
   ${arduino_base.lib_deps}

arch/esp32/esp32s3.ini

@@ -1,6 +1,6 @@
 [esp32s3_base]
 extends = arduino_base
-platform = platformio/espressif32@^5.2.0
+platform = platformio/espressif32@^6.0.0
 build_src_filter = 
   ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2040> -<mesh/eth/>
 upload_speed = 961200
@@ -26,7 +26,7 @@ build_flags =
   -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
   -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
   -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
-  -DDEBUG_HEAP
+  ;-DDEBUG_HEAP
   
 lib_deps =
   ${arduino_base.lib_deps}

arch/portduino/portduino.ini

@@ -12,10 +12,12 @@ build_src_filter =
   -<mesh/http/>
   -<mesh/eth/>
   -<modules/esp32>
-  -<modules/Telemetry>
+  -<modules/Telemetry/EnvironmentTelemetry.cpp>
+  -<modules/Telemetry/AirQualityTelemetry.cpp>
+  -<modules/Telemetry/Sensor>
   +<../variants/portduino>
 lib_deps =
   ${env.lib_deps}
   ${networking_base.lib_deps}
   rweather/Crypto@^0.4.0
-build_flags = ${arduino_base.build_flags} -Isrc/platform/portduino
+build_flags = ${arduino_base.build_flags} -fPIC -Isrc/platform/portduino

arch/rp2040/rp2040.ini

@@ -1,8 +1,6 @@
 ; Common settings for rp2040 Processor based targets
 [rp2040_base]
-platform = https://github.com/maxgerhardt/platform-raspberrypi.git#20c7dbfcfe6677c5305fa28ecf5e3870321cb157
-platform_packages = 
-  earlephilhower/toolchain-rp2040-earlephilhower@^5.100300.221223
+platform = https://github.com/maxgerhardt/platform-raspberrypi.git#9f8c10e50b5acd18e7bfd32638199c655be73a5b
 extends = arduino_base
 board_build.core = earlephilhower
 board_build.filesystem_size = 0.5m

boards/tlora-t3s3-v1.json

@@ -14,7 +14,7 @@
     "f_cpu": "240000000L",
     "f_flash": "80000000L",
     "flash_mode": "dio",
-    "hwids": [["0X303A", "0x1001"]],
+    "hwids": [["0x303A", "0x1001"]],
     "mcu": "esp32s3",
     "variant": "tlora-t3s3-v1"
   },

platformio.ini

@@ -2,7 +2,7 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-;default_envs = tbeam
+default_envs = tbeam
 ;default_envs = pico
 ;default_envs = tbeam-s3-core
 ;default_envs = tbeam0.7
@@ -13,6 +13,7 @@
 ;default_envs = tlora_v1_3
 ;default_envs = tlora-v2
 ;default_envs = tlora-v2-1-1.6
+;default_envs = tlora-t3s3-v1
 ;default_envs = lora-relay-v1 # nrf board
 ;default_envs = t-echo
 ;default_envs = nrf52840dk-geeksville
@@ -93,6 +94,7 @@ build_src_filter = ${env.build_src_filter} -<platform/portduino/>
 lib_deps =
   knolleary/PubSubClient@^2.8
   arduino-libraries/NTPClient@^3.1.0
+  arcao/Syslog@^2.0.0
 
 ; Common libs for environmental measurements in telemetry module 
 ; (not included in native / portduino)
@@ -109,3 +111,4 @@ lib_deps =
   adafruit/Adafruit SHTC3 Library@^1.0.0
   adafruit/Adafruit LPS2X@^2.0.4
   adafruit/Adafruit SHT31 Library@^2.2.0
+  adafruit/Adafruit PM25 AQI Sensor@^1.0.6

src/BluetoothCommon.h

@@ -17,4 +17,14 @@
 extern const uint8_t MESH_SERVICE_UUID_16[], TORADIO_UUID_16[16u], FROMRADIO_UUID_16[], FROMNUM_UUID_16[];
 
 /// Given a level between 0-100, update the BLE attribute
-void updateBatteryLevel(uint8_t level);
+void updateBatteryLevel(uint8_t level);
+
+class BluetoothApi
+{
+  public:
+    virtual void setup();
+    virtual void shutdown();
+    virtual void clearBonds();
+    virtual bool isConnected();
+    virtual int getRssi() = 0;
+};

src/DebugConfiguration.cpp

@@ -0,0 +1,172 @@
+/* based on https://github.com/arcao/Syslog
+
+MIT License
+
+Copyright (c) 2016 Martin Sloup
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+
+#include "configuration.h"
+
+#include "DebugConfiguration.h"
+
+#if HAS_WIFI || HAS_ETHERNET
+
+Syslog::Syslog(UDP &client)
+{
+    this->_client = &client;
+    this->_server = NULL;
+    this->_port = 0;
+    this->_deviceHostname = SYSLOG_NILVALUE;
+    this->_appName = SYSLOG_NILVALUE;
+    this->_priDefault = LOGLEVEL_KERN;
+}
+
+Syslog &Syslog::server(const char *server, uint16_t port)
+{
+    if (this->_ip.fromString(server)) {
+        this->_server = NULL;
+    } else {
+        this->_server = server;
+    }
+    this->_port = port;
+    return *this;
+}
+
+Syslog &Syslog::server(IPAddress ip, uint16_t port)
+{
+    this->_ip = ip;
+    this->_server = NULL;
+    this->_port = port;
+    return *this;
+}
+
+Syslog &Syslog::deviceHostname(const char *deviceHostname)
+{
+    this->_deviceHostname = (deviceHostname == NULL) ? SYSLOG_NILVALUE : deviceHostname;
+    return *this;
+}
+
+Syslog &Syslog::appName(const char *appName)
+{
+    this->_appName = (appName == NULL) ? SYSLOG_NILVALUE : appName;
+    return *this;
+}
+
+Syslog &Syslog::defaultPriority(uint16_t pri)
+{
+    this->_priDefault = pri;
+    return *this;
+}
+
+Syslog &Syslog::logMask(uint8_t priMask)
+{
+    this->_priMask = priMask;
+    return *this;
+}
+
+void Syslog::enable()
+{
+    this->_enabled = true;
+}
+
+void Syslog::disable()
+{
+    this->_enabled = false;
+}
+
+bool Syslog::isEnabled()
+{
+    return this->_enabled;
+}
+
+bool Syslog::vlogf(uint16_t pri, const char *fmt, va_list args)
+{
+    return this->vlogf(pri, this->_appName, fmt, args);
+}
+
+bool Syslog::vlogf(uint16_t pri, const char *appName, const char *fmt, va_list args)
+{
+    char *message;
+    size_t initialLen;
+    size_t len;
+    bool result;
+
+    initialLen = strlen(fmt);
+
+    message = new char[initialLen + 1];
+
+    len = vsnprintf(message, initialLen + 1, fmt, args);
+    if (len > initialLen) {
+        delete[] message;
+        message = new char[len + 1];
+
+        vsnprintf(message, len + 1, fmt, args);
+    }
+
+    result = this->_sendLog(pri, appName, message);
+
+    delete[] message;
+    return result;
+}
+
+inline bool Syslog::_sendLog(uint16_t pri, const char *appName, const char *message)
+{
+    int result;
+
+    if (!this->_enabled)
+        return false;
+
+    if ((this->_server == NULL && this->_ip == INADDR_NONE) || this->_port == 0)
+        return false;
+
+    // Check priority against priMask values.
+    if ((LOG_MASK(LOG_PRI(pri)) & this->_priMask) == 0)
+        return true;
+
+    // Set default facility if none specified.
+    if ((pri & LOG_FACMASK) == 0)
+        pri = LOG_MAKEPRI(LOG_FAC(this->_priDefault), pri);
+
+    if (this->_server != NULL) {
+        result = this->_client->beginPacket(this->_server, this->_port);
+    } else {
+        result = this->_client->beginPacket(this->_ip, this->_port);
+    }
+
+    if (result != 1)
+        return false;
+
+    this->_client->print('<');
+    this->_client->print(pri);
+    this->_client->print(F(">1 - "));
+    this->_client->print(this->_deviceHostname);
+    this->_client->print(' ');
+    this->_client->print(appName);
+    this->_client->print(F(" - - - \xEF\xBB\xBF"));
+    this->_client->print(F("["));
+    this->_client->print(int(millis() / 1000));
+    this->_client->print(F("]: "));
+    this->_client->print(message);
+    this->_client->endPacket();
+
+    return true;
+}
+
+#endif

src/DebugConfiguration.h

@@ -1,3 +1,6 @@
+#ifndef SYSLOG_H
+#define SYSLOG_H
+
 // DEBUG LED
 #ifndef LED_INVERTED
 #define LED_INVERTED 0 // define as 1 if LED is active low (on)
@@ -17,6 +20,7 @@
 #define MESHTASTIC_LOG_LEVEL_INFO "INFO "
 #define MESHTASTIC_LOG_LEVEL_WARN "WARN "
 #define MESHTASTIC_LOG_LEVEL_ERROR "ERROR"
+#define MESHTASTIC_LOG_LEVEL_CRIT "CRIT "
 #define MESHTASTIC_LOG_LEVEL_TRACE "TRACE"
 
 #include "SerialConsole.h"
@@ -28,21 +32,72 @@
 #define LOG_INFO(...) SEGGER_RTT_printf(0, __VA_ARGS__)
 #define LOG_WARN(...) SEGGER_RTT_printf(0, __VA_ARGS__)
 #define LOG_ERROR(...) SEGGER_RTT_printf(0, __VA_ARGS__)
+#define LOG_CRIT(...) SEGGER_RTT_printf(0, __VA_ARGS__)
+#define LOG_TRACE(...) SEGGER_RTT_printf(0, __VA_ARGS__)
 #else
 #ifdef DEBUG_PORT
 #define LOG_DEBUG(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_DEBUG, __VA_ARGS__)
 #define LOG_INFO(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_INFO, __VA_ARGS__)
 #define LOG_WARN(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_WARN, __VA_ARGS__)
 #define LOG_ERROR(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_ERROR, __VA_ARGS__)
-#define LOG_TRACE(...) DEBUG_PORT.log(MESHTASTIC_LOG_TRACE, __VA_ARGS__)
+#define LOG_CRIT(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_CRIT, __VA_ARGS__)
+#define LOG_TRACE(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_TRACE, __VA_ARGS__)
 #else
 #define LOG_DEBUG(...)
 #define LOG_INFO(...)
 #define LOG_WARN(...)
 #define LOG_ERROR(...)
+#define LOG_CRIT(...)
+#define LOG_TRACE(...)
 #endif
 #endif
 
+#define SYSLOG_NILVALUE "-"
+
+#define SYSLOG_CRIT 2  /* critical conditions */
+#define SYSLOG_ERR 3   /* error conditions */
+#define SYSLOG_WARN 4  /* warning conditions */
+#define SYSLOG_INFO 6  /* informational */
+#define SYSLOG_DEBUG 7 /* debug-level messages */
+// trace does not go out to syslog (yet?)
+
+#define LOG_PRIMASK 0x07 /* mask to extract priority part (internal) */
+                         /* extract priority */
+#define LOG_PRI(p) ((p)&LOG_PRIMASK)
+#define LOG_MAKEPRI(fac, pri) (((fac) << 3) | (pri))
+
+/* facility codes */
+#define LOGLEVEL_KERN (0 << 3)      /* kernel messages */
+#define LOGLEVEL_USER (1 << 3)      /* random user-level messages */
+#define LOGLEVEL_MAIL (2 << 3)      /* mail system */
+#define LOGLEVEL_DAEMON (3 << 3)    /* system daemons */
+#define LOGLEVEL_AUTH (4 << 3)      /* security/authorization messages */
+#define LOGLEVEL_SYSLOG (5 << 3)    /* messages generated internally by syslogd */
+#define LOGLEVEL_LPR (6 << 3)       /* line printer subsystem */
+#define LOGLEVEL_NEWS (7 << 3)      /* network news subsystem */
+#define LOGLEVEL_UUCP (8 << 3)      /* UUCP subsystem */
+#define LOGLEVEL_CRON (9 << 3)      /* clock daemon */
+#define LOGLEVEL_AUTHPRIV (10 << 3) /* security/authorization messages (private) */
+#define LOGLEVEL_FTP (11 << 3)      /* ftp daemon */
+
+/* other codes through 15 reserved for system use */
+#define LOGLEVEL_LOCAL0 (16 << 3) /* reserved for local use */
+#define LOGLEVEL_LOCAL1 (17 << 3) /* reserved for local use */
+#define LOGLEVEL_LOCAL2 (18 << 3) /* reserved for local use */
+#define LOGLEVEL_LOCAL3 (19 << 3) /* reserved for local use */
+#define LOGLEVEL_LOCAL4 (20 << 3) /* reserved for local use */
+#define LOGLEVEL_LOCAL5 (21 << 3) /* reserved for local use */
+#define LOGLEVEL_LOCAL6 (22 << 3) /* reserved for local use */
+#define LOGLEVEL_LOCAL7 (23 << 3) /* reserved for local use */
+
+#define LOG_NFACILITIES 24 /* current number of facilities */
+#define LOG_FACMASK 0x03f8 /* mask to extract facility part */
+                           /* facility of pri */
+#define LOG_FAC(p) (((p)&LOG_FACMASK) >> 3)
+
+#define LOG_MASK(pri) (1 << (pri))             /* mask for one priority */
+#define LOG_UPTO(pri) ((1 << ((pri) + 1)) - 1) /* all priorities through pri */
+
 // -----------------------------------------------------------------------------
 // AXP192 (Rev1-specific options)
 // -----------------------------------------------------------------------------
@@ -52,3 +107,50 @@
 
 // Default Bluetooth PIN
 #define defaultBLEPin 123456
+
+#if HAS_ETHERNET
+#include <RAK13800_W5100S.h>
+#endif // HAS_ETHERNET
+
+#if HAS_WIFI
+#include <WiFi.h>
+#endif // HAS_WIFI
+
+#if HAS_WIFI || HAS_ETHERNET
+
+class Syslog
+{
+  private:
+    UDP *_client;
+    IPAddress _ip;
+    const char *_server;
+    uint16_t _port;
+    const char *_deviceHostname;
+    const char *_appName;
+    uint16_t _priDefault;
+    uint8_t _priMask = 0xff;
+    bool _enabled = false;
+
+    bool _sendLog(uint16_t pri, const char *appName, const char *message);
+
+  public:
+    explicit Syslog(UDP &client);
+
+    Syslog &server(const char *server, uint16_t port);
+    Syslog &server(IPAddress ip, uint16_t port);
+    Syslog &deviceHostname(const char *deviceHostname);
+    Syslog &appName(const char *appName);
+    Syslog &defaultPriority(uint16_t pri = LOGLEVEL_KERN);
+    Syslog &logMask(uint8_t priMask);
+
+    void enable();
+    void disable();
+    bool isEnabled();
+
+    bool vlogf(uint16_t pri, const char *fmt, va_list args) __attribute__((format(printf, 3, 0)));
+    bool vlogf(uint16_t pri, const char *appName, const char *fmt, va_list args) __attribute__((format(printf, 3, 0)));
+};
+
+#endif // HAS_ETHERNET || HAS_WIFI
+
+#endif // SYSLOG_H

src/Power.cpp

@@ -7,6 +7,12 @@
 #include "sleep.h"
 #include "utils.h"
 
+#ifdef DEBUG_HEAP_MQTT
+#include "mqtt/MQTT.h"
+#include "target_specific.h"
+#include <WiFi.h>
+#endif
+
 #ifdef HAS_PMU
 #include "XPowersAXP192.tpp"
 #include "XPowersAXP2101.tpp"
@@ -311,6 +317,25 @@ void Power::readPowerStatus()
                       ESP.getFreeHeap() - lastheap, running, concurrency::mainController.size(false));
             lastheap = ESP.getFreeHeap();
         }
+#ifdef DEBUG_HEAP_MQTT
+        if (mqtt) {
+            // send MQTT-Packet with Heap-Size
+            uint8_t dmac[6];
+            getMacAddr(dmac); // Get our hardware ID
+            char mac[18];
+            sprintf(mac, "!%02x%02x%02x%02x", dmac[2], dmac[3], dmac[4], dmac[5]);
+            auto newHeap = ESP.getFreeHeap();
+            std::string heapTopic = "msh/2/heap/" + std::string(mac);
+            std::string heapString = std::to_string(newHeap);
+            mqtt->pubSub.publish(heapTopic.c_str(), heapString.c_str(), false);
+            // auto fragHeap = ESP.getHeapFragmentation();
+            auto wifiRSSI = WiFi.RSSI();
+            heapTopic = "msh/2/wifi/" + std::string(mac);
+            std::string wifiString = std::to_string(wifiRSSI);
+            mqtt->pubSub.publish(heapTopic.c_str(), wifiString.c_str(), false);
+        }
+#endif
+
 #endif
 
 // If we have a battery at all and it is less than 10% full, force deep sleep if we have more than 3 low readings in a row

src/PowerFSM.cpp

@@ -78,8 +78,8 @@ static void lsIdle()
             case ESP_SLEEP_WAKEUP_TIMER:
                 // Normal case: timer expired, we should just go back to sleep ASAP
 
-                setLed(true);                 // briefly turn on led
-                wakeCause2 = doLightSleep(1); // leave led on for 1ms
+                setLed(true);                   // briefly turn on led
+                wakeCause2 = doLightSleep(100); // leave led on for 1ms
 
                 secsSlept += sleepTime;
                 // LOG_INFO("sleeping, flash led!\n");

src/RF95Configuration.h

@@ -2,6 +2,6 @@
 #ifdef USE_RF95
 #define RF95_RESET LORA_RESET
 #define RF95_IRQ LORA_DIO0  // on SX1262 version this is a no connect DIO0
-#define RF95_DIO1 LORA_DIO1 // Note: not really used for RF95
+#define RF95_DIO1 LORA_DIO1 // Note: not really used for RF95, but used for pure SX127x
 #define RF95_DIO2 LORA_DIO2 // Note: not really used for RF95
 #endif

src/RedirectablePrint.cpp

@@ -5,6 +5,8 @@
 #include "configuration.h"
 #include <assert.h>
 #include <cstring>
+#include <memory>
+#include <stdexcept>
 #include <sys/time.h>
 #include <time.h>
 
@@ -13,6 +15,10 @@
  */
 NoopPrint noopPrint;
 
+#if HAS_WIFI || HAS_ETHERNET
+extern Syslog syslog;
+#endif
+
 void RedirectablePrint::setDestination(Print *_dest)
 {
     assert(_dest);
@@ -96,6 +102,39 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
             }
         }
         r += vprintf(format, arg);
+
+#if (HAS_WIFI || HAS_ETHERNET) && !defined(ARCH_PORTDUINO)
+        // if syslog is in use, collect the log messages and send them to syslog
+        if (syslog.isEnabled()) {
+            int ll = 0;
+            switch (logLevel[0]) {
+            case 'D':
+                ll = SYSLOG_DEBUG;
+                break;
+            case 'I':
+                ll = SYSLOG_INFO;
+                break;
+            case 'W':
+                ll = SYSLOG_WARN;
+                break;
+            case 'E':
+                ll = SYSLOG_ERR;
+                break;
+            case 'C':
+                ll = SYSLOG_CRIT;
+                break;
+            default:
+                ll = 0;
+            }
+            auto thread = concurrency::OSThread::currentThread;
+            if (thread) {
+                syslog.vlogf(ll, thread->ThreadName.c_str(), format, arg);
+            } else {
+                syslog.vlogf(ll, format, arg);
+            }
+        }
+#endif
+
         va_end(arg);
 
         isContinuationMessage = !hasNewline;
@@ -136,3 +175,22 @@ void RedirectablePrint::hexDump(const char *logLevel, unsigned char *buf, uint16
     }
     log(logLevel, "   +------------------------------------------------+ +----------------+\n");
 }
+
+std::string RedirectablePrint::mt_sprintf(const std::string fmt_str, ...)
+{
+    int n = ((int)fmt_str.size()) * 2; /* Reserve two times as much as the length of the fmt_str */
+    std::unique_ptr<char[]> formatted;
+    va_list ap;
+    while (1) {
+        formatted.reset(new char[n]); /* Wrap the plain char array into the unique_ptr */
+        strcpy(&formatted[0], fmt_str.c_str());
+        va_start(ap, fmt_str);
+        int final_n = vsnprintf(&formatted[0], n, fmt_str.c_str(), ap);
+        va_end(ap);
+        if (final_n < 0 || final_n >= n)
+            n += abs(final_n - n + 1);
+        else
+            break;
+    }
+    return std::string(formatted.get());
+}

src/RedirectablePrint.h

@@ -2,6 +2,7 @@
 
 #include <Print.h>
 #include <stdarg.h>
+#include <string>
 
 /**
  * A Printable that can be switched to squirt its bytes to a different sink.
@@ -40,6 +41,8 @@ class RedirectablePrint : public Print
     size_t vprintf(const char *format, va_list arg);
 
     void hexDump(const char *logLevel, unsigned char *buf, uint16_t len);
+
+    std::string mt_sprintf(const std::string fmt_str, ...);
 };
 
 class NoopPrint : public Print

src/configuration.h

@@ -116,6 +116,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define LPS22HB_ADDR 0x5C
 #define LPS22HB_ADDR_ALT 0x5D
 #define SHT31_ADDR 0x44
+#define PMSA0031_ADDR 0x12
 
 // -----------------------------------------------------------------------------
 // Security

src/detect/i2cScan.h

@@ -218,6 +218,10 @@ void scanI2Cdevice()
                 LOG_INFO("QMC5883L Highrate 3-Axis magnetic sensor found\n");
                 nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_QMC5883L] = addr;
             }
+            if (addr == PMSA0031_ADDR) {
+                LOG_INFO("PMSA0031 air quality sensor found\n");
+                nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_PMSA003I] = addr;
+            }
         } else if (err == 4) {
             LOG_ERROR("Unknow error at address 0x%x\n", addr);
         }

src/graphics/Screen.cpp

@@ -50,6 +50,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "fonts/OLEDDisplayFontsRU.h"
 #endif
 
+#ifdef OLED_UA
+#include "fonts/OLEDDisplayFontsUA.h"
+#endif
+
 using namespace meshtastic; /** @todo remove */
 
 namespace graphics
@@ -70,6 +74,8 @@ static char btPIN[16] = "888888";
 
 uint32_t logo_timeout = 5000; // 4 seconds for EACH logo
 
+uint32_t hours_in_month = 730;
+
 // This image definition is here instead of images.h because it's modified dynamically by the drawBattery function
 uint8_t imgBattery[16] = {0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xE7, 0x3C};
 
@@ -104,8 +110,12 @@ static uint16_t displayWidth, displayHeight;
 #ifdef OLED_RU
 #define FONT_SMALL ArialMT_Plain_10_RU
 #else
+#ifdef OLED_UA
+#define FONT_SMALL ArialMT_Plain_10_UA
+#else
 #define FONT_SMALL ArialMT_Plain_10 // Height: 13
 #endif
+#endif
 #define FONT_MEDIUM ArialMT_Plain_16 // Height: 19
 #define FONT_LARGE ArialMT_Plain_24  // Height: 28
 #endif
@@ -380,13 +390,17 @@ static void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state
         display->setColor(BLACK);
     }
 
-    tm *tm = localtime(reinterpret_cast<const time_t *>(&mp.rx_time));
+    uint32_t seconds = sinceReceived(&mp);
+    uint32_t minutes = seconds / 60;
+    uint32_t hours = minutes / 60;
+    uint32_t days = hours / 24;
 
     if (config.display.heading_bold) {
-        display->drawStringf(1 + x, 0 + y, tempBuf, "[%02d:%02d:%02d] From: %s", tm->tm_hour, tm->tm_min, tm->tm_sec,
+        display->drawStringf(1 + x, 0 + y, tempBuf, "%s ago from %s",
+                             screen->drawTimeDelta(days, hours, minutes, seconds).c_str(),
                              (node && node->has_user) ? node->user.short_name : "???");
     }
-    display->drawStringf(0 + x, 0 + y, tempBuf, "[%02d:%02d:%02d] From: %s", tm->tm_hour, tm->tm_min, tm->tm_sec,
+    display->drawStringf(0 + x, 0 + y, tempBuf, "%s ago from %s", screen->drawTimeDelta(days, hours, minutes, seconds).c_str(),
                          (node && node->has_user) ? node->user.short_name : "???");
 
     display->setColor(WHITE);
@@ -417,38 +431,6 @@ static void drawColumns(OLEDDisplay *display, int16_t x, int16_t y, const char *
     }
 }
 
-#if 0
-    /// Draw a series of fields in a row, wrapping to multiple rows if needed
-    /// @return the max y we ended up printing to
-    static uint32_t drawRows(OLEDDisplay *display, int16_t x, int16_t y, const char **fields)
-    {
-        // The coordinates define the left starting point of the text
-        display->setTextAlignment(TEXT_ALIGN_LEFT);
-
-        const char **f = fields;
-        int xo = x, yo = y;
-        const int COLUMNS = 2; // hardwired for two columns per row....
-        int col = 0;           // track which column we are on
-        while (*f) {
-            display->drawString(xo, yo, *f);
-            xo += SCREEN_WIDTH / COLUMNS;
-            // Wrap to next row, if needed.
-            if (++col >= COLUMNS) {
-                xo = x;
-                yo += FONT_HEIGHT_SMALL;
-                col = 0;
-            }
-            f++;
-        }
-        if (col != 0) {
-            // Include last incomplete line in our total.
-            yo += FONT_HEIGHT_SMALL;
-        }
-
-        return yo;
-    }
-#endif
-
 // Draw power bars or a charging indicator on an image of a battery, determined by battery charge voltage or percentage.
 static void drawBattery(OLEDDisplay *display, int16_t x, int16_t y, uint8_t *imgBuffer, const PowerStatus *powerStatus)
 {
@@ -536,18 +518,12 @@ static void drawGPS(OLEDDisplay *display, int16_t x, int16_t y, const GPSStatus
 // Draw status when gps is disabled by PMU
 static void drawGPSpowerstat(OLEDDisplay *display, int16_t x, int16_t y, const GPSStatus *gps)
 {
-#ifdef HAS_PMU
     String displayLine = "GPS disabled";
     int16_t xPos = display->getStringWidth(displayLine);
 
     if (!config.position.gps_enabled) {
         display->drawString(x + xPos, y, displayLine);
-#ifdef GPS_POWER_TOGGLE
-        display->drawString(x + xPos, y - 2 + FONT_HEIGHT_SMALL, " by button");
-#endif
-        // display->drawString(x + xPos, y + 2, displayLine);
     }
-#endif
 }
 
 static void drawGPSAltitude(OLEDDisplay *display, int16_t x, int16_t y, const GPSStatus *gps)
@@ -823,9 +799,6 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
     else if (agoSecs < 120 * 60) // last 2 hrs
         snprintf(lastStr, sizeof(lastStr), "%u minutes ago", agoSecs / 60);
     else {
-
-        uint32_t hours_in_month = 730;
-
         // Only show hours ago if it's been less than 6 months. Otherwise, we may have bad
         //   data.
         if ((agoSecs / 60 / 60) < (hours_in_month * 6)) {
@@ -1365,6 +1338,23 @@ void Screen::blink()
     dispdev.setBrightness(brightness);
 }
 
+std::string Screen::drawTimeDelta(uint32_t days, uint32_t hours, uint32_t minutes, uint32_t seconds)
+{
+    std::string uptime;
+
+    if (days > (hours_in_month * 6))
+        uptime = "?";
+    else if (days >= 2)
+        uptime = std::to_string(days) + "d";
+    else if (hours >= 2)
+        uptime = std::to_string(hours) + "h";
+    else if (minutes >= 1)
+        uptime = std::to_string(minutes) + "m";
+    else
+        uptime = std::to_string(seconds) + "s";
+    return uptime;
+}
+
 void Screen::handlePrint(const char *text)
 {
     // the string passed into us probably has a newline, but that would confuse the logging system
@@ -1444,11 +1434,7 @@ void DebugInfo::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     }
     // Display GPS status
     if (!config.position.gps_enabled) {
-        int16_t yPos = y + 2;
-#ifdef GPS_POWER_TOGGLE
-        yPos = (y + 10 + FONT_HEIGHT_SMALL);
-#endif
-        drawGPSpowerstat(display, x, yPos, gpsStatus);
+        drawGPSpowerstat(display, x, y + 2, gpsStatus);
     } else {
         if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT) {
             drawGPS(display, x + (SCREEN_WIDTH * 0.63), y + 2, gpsStatus);
@@ -1729,15 +1715,7 @@ void DebugInfo::drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *stat
     display->setColor(WHITE);
 
     // Show uptime as days, hours, minutes OR seconds
-    String uptime;
-    if (days >= 2)
-        uptime += String(days) + "d ";
-    else if (hours >= 2)
-        uptime += String(hours) + "h ";
-    else if (minutes >= 1)
-        uptime += String(minutes) + "m ";
-    else
-        uptime += String(seconds) + "s ";
+    std::string uptime = screen->drawTimeDelta(days, hours, minutes, seconds);
 
     uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice);
     if (rtc_sec > 0) {
@@ -1752,12 +1730,12 @@ void DebugInfo::drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *stat
         int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
         int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
 
-        char timebuf[9];
-        snprintf(timebuf, sizeof(timebuf), "%02d:%02d:%02d", hour, min, sec);
+        char timebuf[10];
+        snprintf(timebuf, sizeof(timebuf), " %02d:%02d:%02d", hour, min, sec);
         uptime += timebuf;
     }
 
-    display->drawString(x, y + FONT_HEIGHT_SMALL * 1, uptime);
+    display->drawString(x, y + FONT_HEIGHT_SMALL * 1, uptime.c_str());
 
     // Display Channel Utilization
     char chUtil[13];
@@ -1773,6 +1751,9 @@ void DebugInfo::drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *stat
         drawGPScoordinates(display, x, y + FONT_HEIGHT_SMALL * 3, gpsStatus);
     } else {
         drawGPSpowerstat(display, x - (SCREEN_WIDTH / 4), y + FONT_HEIGHT_SMALL * 2, gpsStatus);
+#ifdef GPS_POWER_TOGGLE
+        display->drawString(x + 30, (y + FONT_HEIGHT_SMALL * 3), " by button");
+#endif
     }
     /* Display a heartbeat pixel that blinks every time the frame is redrawn */
 #ifdef SHOW_REDRAWS

src/graphics/Screen.h

@@ -206,6 +206,9 @@ class Screen : public concurrency::OSThread
         }
     }
 
+    /// generates a very brief time delta display
+    std::string drawTimeDelta(uint32_t days, uint32_t hours, uint32_t minutes, uint32_t seconds);
+
     /// Overrides the default utf8 character conversion, to replace empty space with question marks
     static char customFontTableLookup(const uint8_t ch)
     {
@@ -237,6 +240,12 @@ class Screen : public concurrency::OSThread
         // library have empty chars for non-latin ASCII symbols
         case 0xD0: {
             SKIPREST = false;
+            if (ch == 132)
+                return (uint8_t)(170); // Є
+            if (ch == 134)
+                return (uint8_t)(178); // І
+            if (ch == 135)
+                return (uint8_t)(175); // Ї
             if (ch == 129)
                 return (uint8_t)(168); // Ё
             if (ch > 143 && ch < 192)
@@ -245,12 +254,26 @@ class Screen : public concurrency::OSThread
         }
         case 0xD1: {
             SKIPREST = false;
+            if (ch == 148)
+                return (uint8_t)(186); // є
+            if (ch == 150)
+                return (uint8_t)(179); // і
+            if (ch == 151)
+                return (uint8_t)(191); // ї
             if (ch == 145)
                 return (uint8_t)(184); // ё
             if (ch > 127 && ch < 144)
                 return (uint8_t)(ch + 112);
             break;
         }
+        case 0xD2: {
+            SKIPREST = false;
+            if (ch == 144)
+                return (uint8_t)(165); // Ґ
+            if (ch == 145)
+                return (uint8_t)(180); // ґ
+            break;
+        }
         }
 
         // We want to strip out prefix chars for two-byte char formats

src/graphics/fonts/OLEDDisplayFontsUA.cpp

@@ -0,0 +1,424 @@
+#include "OLEDDisplayFontsUA.h"
+
+// Font generated or edited with the glyphEditor
+const uint8_t ArialMT_Plain_10_UA[] PROGMEM = {
+    0x0A, // Width: 10
+    0x0D, // Height: 13
+    0x20, // First char: 32
+    0xE0, // Number of chars: 224
+    // Jump Table:
+    0xFF, 0xFF, 0x00, 0x0A, // 32
+    0x00, 0x00, 0x04, 0x03, // 33
+    0x00, 0x04, 0x05, 0x04, // 34
+    0x00, 0x09, 0x09, 0x06, // 35
+    0x00, 0x12, 0x0A, 0x06, // 36
+    0x00, 0x1C, 0x10, 0x09, // 37
+    0x00, 0x2C, 0x0E, 0x08, // 38
+    0x00, 0x3A, 0x01, 0x02, // 39
+    0x00, 0x3B, 0x06, 0x04, // 40
+    0x00, 0x41, 0x06, 0x04, // 41
+    0x00, 0x47, 0x05, 0x04, // 42
+    0x00, 0x4C, 0x09, 0x06, // 43
+    0x00, 0x55, 0x04, 0x03, // 44
+    0x00, 0x59, 0x03, 0x03, // 45
+    0x00, 0x5C, 0x04, 0x03, // 46
+    0x00, 0x60, 0x05, 0x04, // 47
+    0x00, 0x65, 0x0A, 0x06, // 48
+    0x00, 0x6F, 0x08, 0x05, // 49
+    0x00, 0x77, 0x0A, 0x06, // 50
+    0x00, 0x81, 0x0A, 0x06, // 51
+    0x00, 0x8B, 0x0B, 0x07, // 52
+    0x00, 0x96, 0x0A, 0x06, // 53
+    0x00, 0xA0, 0x0A, 0x06, // 54
+    0x00, 0xAA, 0x09, 0x06, // 55
+    0x00, 0xB3, 0x0A, 0x06, // 56
+    0x00, 0xBD, 0x0A, 0x06, // 57
+    0x00, 0xC7, 0x04, 0x03, // 58
+    0x00, 0xCB, 0x04, 0x03, // 59
+    0x00, 0xCF, 0x0A, 0x06, // 60
+    0x00, 0xD9, 0x09, 0x06, // 61
+    0x00, 0xE2, 0x09, 0x06, // 62
+    0x00, 0xEB, 0x0B, 0x07, // 63
+    0x00, 0xF6, 0x14, 0x0B, // 64
+    0x01, 0x0A, 0x0E, 0x08, // 65
+    0x01, 0x18, 0x0C, 0x07, // 66
+    0x01, 0x24, 0x0C, 0x07, // 67
+    0x01, 0x30, 0x0B, 0x07, // 68
+    0x01, 0x3B, 0x0C, 0x07, // 69
+    0x01, 0x47, 0x09, 0x06, // 70
+    0x01, 0x50, 0x0D, 0x08, // 71
+    0x01, 0x5D, 0x0C, 0x07, // 72
+    0x01, 0x69, 0x04, 0x03, // 73
+    0x01, 0x6D, 0x08, 0x05, // 74
+    0x01, 0x75, 0x0E, 0x08, // 75
+    0x01, 0x83, 0x0C, 0x07, // 76
+    0x01, 0x8F, 0x10, 0x09, // 77
+    0x01, 0x9F, 0x0C, 0x07, // 78
+    0x01, 0xAB, 0x0E, 0x08, // 79
+    0x01, 0xB9, 0x0B, 0x07, // 80
+    0x01, 0xC4, 0x0E, 0x08, // 81
+    0x01, 0xD2, 0x0C, 0x07, // 82
+    0x01, 0xDE, 0x0C, 0x07, // 83
+    0x01, 0xEA, 0x0B, 0x07, // 84
+    0x01, 0xF5, 0x0C, 0x07, // 85
+    0x02, 0x01, 0x0D, 0x08, // 86
+    0x02, 0x0E, 0x11, 0x0A, // 87
+    0x02, 0x1F, 0x0E, 0x08, // 88
+    0x02, 0x2D, 0x0D, 0x08, // 89
+    0x02, 0x3A, 0x0C, 0x07, // 90
+    0x02, 0x46, 0x06, 0x04, // 91
+    0x02, 0x4C, 0x06, 0x04, // 92
+    0x02, 0x52, 0x04, 0x03, // 93
+    0x02, 0x56, 0x09, 0x06, // 94
+    0x02, 0x5F, 0x0C, 0x07, // 95
+    0x02, 0x6B, 0x03, 0x03, // 96
+    0x02, 0x6E, 0x0A, 0x06, // 97
+    0x02, 0x78, 0x0A, 0x06, // 98
+    0x02, 0x82, 0x0A, 0x06, // 99
+    0x02, 0x8C, 0x0A, 0x06, // 100
+    0x02, 0x96, 0x0A, 0x06, // 101
+    0x02, 0xA0, 0x05, 0x04, // 102
+    0x02, 0xA5, 0x0A, 0x06, // 103
+    0x02, 0xAF, 0x0A, 0x06, // 104
+    0x02, 0xB9, 0x04, 0x03, // 105
+    0x02, 0xBD, 0x04, 0x03, // 106
+    0x02, 0xC1, 0x08, 0x05, // 107
+    0x02, 0xC9, 0x04, 0x03, // 108
+    0x02, 0xCD, 0x10, 0x09, // 109
+    0x02, 0xDD, 0x0A, 0x06, // 110
+    0x02, 0xE7, 0x0A, 0x06, // 111
+    0x02, 0xF1, 0x0A, 0x06, // 112
+    0x02, 0xFB, 0x0A, 0x06, // 113
+    0x03, 0x05, 0x05, 0x04, // 114
+    0x03, 0x0A, 0x08, 0x05, // 115
+    0x03, 0x12, 0x06, 0x04, // 116
+    0x03, 0x18, 0x0A, 0x06, // 117
+    0x03, 0x22, 0x09, 0x06, // 118
+    0x03, 0x2B, 0x0E, 0x08, // 119
+    0x03, 0x39, 0x0A, 0x06, // 120
+    0x03, 0x43, 0x09, 0x06, // 121
+    0x03, 0x4C, 0x0A, 0x06, // 122
+    0x03, 0x56, 0x06, 0x04, // 123
+    0x03, 0x5C, 0x04, 0x03, // 124
+    0x03, 0x60, 0x05, 0x04, // 125
+    0x03, 0x65, 0x09, 0x06, // 126
+    0xFF, 0xFF, 0x00, 0x0A, // 127
+    0xFF, 0xFF, 0x00, 0x0A, // 128
+    0xFF, 0xFF, 0x00, 0x0A, // 129
+    0xFF, 0xFF, 0x00, 0x0A, // 130
+    0xFF, 0xFF, 0x00, 0x0A, // 131
+    0xFF, 0xFF, 0x00, 0x0A, // 132
+    0xFF, 0xFF, 0x00, 0x0A, // 133
+    0xFF, 0xFF, 0x00, 0x0A, // 134
+    0xFF, 0xFF, 0x00, 0x0A, // 135
+    0xFF, 0xFF, 0x00, 0x0A, // 136
+    0xFF, 0xFF, 0x00, 0x0A, // 137
+    0xFF, 0xFF, 0x00, 0x0A, // 138
+    0xFF, 0xFF, 0x00, 0x0A, // 139
+    0xFF, 0xFF, 0x00, 0x0A, // 140
+    0xFF, 0xFF, 0x00, 0x0A, // 141
+    0xFF, 0xFF, 0x00, 0x0A, // 142
+    0xFF, 0xFF, 0x00, 0x0A, // 143
+    0xFF, 0xFF, 0x00, 0x0A, // 144
+    0xFF, 0xFF, 0x00, 0x0A, // 145
+    0xFF, 0xFF, 0x00, 0x0A, // 146
+    0xFF, 0xFF, 0x00, 0x0A, // 147
+    0xFF, 0xFF, 0x00, 0x0A, // 148
+    0xFF, 0xFF, 0x00, 0x0A, // 149
+    0xFF, 0xFF, 0x00, 0x0A, // 150
+    0xFF, 0xFF, 0x00, 0x0A, // 151
+    0xFF, 0xFF, 0x00, 0x0A, // 152
+    0xFF, 0xFF, 0x00, 0x0A, // 153
+    0xFF, 0xFF, 0x00, 0x0A, // 154
+    0xFF, 0xFF, 0x00, 0x0A, // 155
+    0xFF, 0xFF, 0x00, 0x0A, // 156
+    0xFF, 0xFF, 0x00, 0x0A, // 157
+    0xFF, 0xFF, 0x00, 0x0A, // 158
+    0xFF, 0xFF, 0x00, 0x0A, // 159
+    0xFF, 0xFF, 0x00, 0x0A, // 160
+    0x03, 0x6E, 0x04, 0x03, // 161
+    0x03, 0x72, 0x0A, 0x06, // 162
+    0x03, 0x7C, 0x0C, 0x07, // 163
+    0x03, 0x88, 0x0A, 0x06, // 164
+    0x03, 0x92, 0x09, 0x06, // 165
+    0x03, 0x9B, 0x04, 0x03, // 166
+    0x03, 0x9F, 0x0A, 0x06, // 167
+    0x03, 0xA9, 0x0C, 0x07, // 168
+    0x03, 0xB5, 0x0D, 0x08, // 169
+    0x03, 0xC2, 0x0C, 0x07, // 170
+    0x03, 0xCE, 0x0A, 0x06, // 171
+    0x03, 0xD8, 0x09, 0x06, // 172
+    0x03, 0xE1, 0x03, 0x03, // 173
+    0x03, 0xE4, 0x0D, 0x08, // 174
+    0x03, 0xF1, 0x0C, 0x07, // 175
+    0x03, 0xFD, 0x07, 0x05, // 176
+    0x04, 0x04, 0x0A, 0x06, // 177
+    0x04, 0x0E, 0x0C, 0x07, // 178
+    0x04, 0x1A, 0x0C, 0x07, // 179
+    0x04, 0x26, 0x07, 0x05, // 180
+    0x04, 0x2D, 0x0A, 0x06, // 181
+    0x04, 0x37, 0x09, 0x06, // 182
+    0x04, 0x40, 0x03, 0x03, // 183
+    0x04, 0x43, 0x0B, 0x07, // 184
+    0x04, 0x4E, 0x0B, 0x07, // 185
+    0x04, 0x59, 0x0C, 0x07, // 186
+    0x04, 0x65, 0x0A, 0x06, // 187
+    0x04, 0x6F, 0x10, 0x09, // 188
+    0x04, 0x7F, 0x10, 0x09, // 189
+    0x04, 0x8F, 0x10, 0x09, // 190
+    0x04, 0x9F, 0x0A, 0x06, // 191
+    0x04, 0xA9, 0x0C, 0x07, // 192
+    0x04, 0xB5, 0x0C, 0x07, // 193
+    0x04, 0xC1, 0x0C, 0x07, // 194
+    0x04, 0xCD, 0x0B, 0x07, // 195
+    0x04, 0xD8, 0x0C, 0x07, // 196
+    0x04, 0xE4, 0x0C, 0x07, // 197
+    0x04, 0xF0, 0x0C, 0x07, // 198
+    0x04, 0xFC, 0x0C, 0x07, // 199
+    0x05, 0x08, 0x0C, 0x07, // 200
+    0x05, 0x14, 0x0C, 0x07, // 201
+    0x05, 0x20, 0x0C, 0x07, // 202
+    0x05, 0x2C, 0x0C, 0x07, // 203
+    0x05, 0x38, 0x0C, 0x07, // 204
+    0x05, 0x44, 0x0C, 0x07, // 205
+    0x05, 0x50, 0x0C, 0x07, // 206
+    0x05, 0x5C, 0x0C, 0x07, // 207
+    0x05, 0x68, 0x0B, 0x07, // 208
+    0x05, 0x73, 0x0C, 0x07, // 209
+    0x05, 0x7F, 0x0B, 0x07, // 210
+    0x05, 0x8A, 0x0C, 0x07, // 211
+    0x05, 0x96, 0x0B, 0x07, // 212
+    0x05, 0xA1, 0x0C, 0x07, // 213
+    0x05, 0xAD, 0x0C, 0x07, // 214
+    0x05, 0xB9, 0x0C, 0x07, // 215
+    0x05, 0xC5, 0x0C, 0x07, // 216
+    0x05, 0xD1, 0x0E, 0x08, // 217
+    0x05, 0xDF, 0x0C, 0x07, // 218
+    0x05, 0xEB, 0x0C, 0x07, // 219
+    0x05, 0xF7, 0x0C, 0x07, // 220
+    0x06, 0x03, 0x0C, 0x07, // 221
+    0x06, 0x0F, 0x0C, 0x07, // 222
+    0x06, 0x1B, 0x0C, 0x07, // 223
+    0x06, 0x27, 0x0C, 0x07, // 224
+    0x06, 0x33, 0x0C, 0x07, // 225
+    0x06, 0x3F, 0x0C, 0x07, // 226
+    0x06, 0x4B, 0x0B, 0x07, // 227
+    0x06, 0x56, 0x0C, 0x07, // 228
+    0x06, 0x62, 0x0B, 0x07, // 229
+    0x06, 0x6D, 0x0C, 0x07, // 230
+    0x06, 0x79, 0x0C, 0x07, // 231
+    0x06, 0x85, 0x0C, 0x07, // 232
+    0x06, 0x91, 0x0C, 0x07, // 233
+    0x06, 0x9D, 0x0C, 0x07, // 234
+    0x06, 0xA9, 0x0C, 0x07, // 235
+    0x06, 0xB5, 0x0C, 0x07, // 236
+    0x06, 0xC1, 0x0C, 0x07, // 237
+    0x06, 0xCD, 0x0C, 0x07, // 238
+    0x06, 0xD9, 0x0C, 0x07, // 239
+    0x06, 0xE5, 0x0B, 0x07, // 240
+    0x06, 0xF0, 0x0C, 0x07, // 241
+    0x06, 0xFC, 0x0B, 0x07, // 242
+    0x07, 0x07, 0x0C, 0x07, // 243
+    0x07, 0x13, 0x0B, 0x07, // 244
+    0x07, 0x1E, 0x0C, 0x07, // 245
+    0x07, 0x2A, 0x0C, 0x07, // 246
+    0x07, 0x36, 0x0C, 0x07, // 247
+    0x07, 0x42, 0x0C, 0x07, // 248
+    0x07, 0x4E, 0x0E, 0x08, // 249
+    0x07, 0x5C, 0x0C, 0x07, // 250
+    0x07, 0x68, 0x0C, 0x07, // 251
+    0x07, 0x74, 0x0C, 0x07, // 252
+    0x07, 0x80, 0x0C, 0x07, // 253
+    0x07, 0x8C, 0x0C, 0x07, // 254
+    0x07, 0x98, 0x0C, 0x07, // 255
+    // Font Data:
+    0x00, 0x00, 0xF8, 0x02,                                                                                                 // 33
+    0x38, 0x00, 0x00, 0x00, 0x38,                                                                                           // 34
+    0xA0, 0x03, 0xE0, 0x00, 0xB8, 0x03, 0xE0, 0x00, 0xB8,                                                                   // 35
+    0x30, 0x01, 0x28, 0x02, 0xF8, 0x07, 0x48, 0x02, 0x90, 0x01,                                                             // 36
+    0x00, 0x00, 0x30, 0x00, 0x48, 0x00, 0x30, 0x03, 0xC0, 0x00, 0xB0, 0x01, 0x48, 0x02, 0x80, 0x01,                         // 37
+    0x80, 0x01, 0x50, 0x02, 0x68, 0x02, 0xA8, 0x02, 0x18, 0x01, 0x80, 0x03, 0x80, 0x02,                                     // 38
+    0x38,                                                                                                                   // 39
+    0xE0, 0x03, 0x10, 0x04, 0x08, 0x08,                                                                                     // 40
+    0x08, 0x08, 0x10, 0x04, 0xE0, 0x03,                                                                                     // 41
+    0x28, 0x00, 0x18, 0x00, 0x28,                                                                                           // 42
+    0x40, 0x00, 0x40, 0x00, 0xF0, 0x01, 0x40, 0x00, 0x40,                                                                   // 43
+    0x00, 0x00, 0x00, 0x06,                                                                                                 // 44
+    0x80, 0x00, 0x80,                                                                                                       // 45
+    0x00, 0x00, 0x00, 0x02,                                                                                                 // 46
+    0x00, 0x03, 0xE0, 0x00, 0x18,                                                                                           // 47
+    0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0xF0, 0x01,                                                             // 48
+    0x00, 0x00, 0x20, 0x00, 0x10, 0x00, 0xF8, 0x03,                                                                         // 49
+    0x10, 0x02, 0x08, 0x03, 0x88, 0x02, 0x48, 0x02, 0x30, 0x02,                                                             // 50
+    0x10, 0x01, 0x08, 0x02, 0x48, 0x02, 0x48, 0x02, 0xB0, 0x01,                                                             // 51
+    0xC0, 0x00, 0xA0, 0x00, 0x90, 0x00, 0x88, 0x00, 0xF8, 0x03, 0x80,                                                       // 52
+    0x60, 0x01, 0x38, 0x02, 0x28, 0x02, 0x28, 0x02, 0xC8, 0x01,                                                             // 53
+    0xF0, 0x01, 0x28, 0x02, 0x28, 0x02, 0x28, 0x02, 0xD0, 0x01,                                                             // 54
+    0x08, 0x00, 0x08, 0x03, 0xC8, 0x00, 0x38, 0x00, 0x08,                                                                   // 55
+    0xB0, 0x01, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0xB0, 0x01,                                                             // 56
+    0x70, 0x01, 0x88, 0x02, 0x88, 0x02, 0x88, 0x02, 0xF0, 0x01,                                                             // 57
+    0x00, 0x00, 0x20, 0x02,                                                                                                 // 58
+    0x00, 0x00, 0x20, 0x06,                                                                                                 // 59
+    0x00, 0x00, 0x40, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0x10, 0x01,                                                             // 60
+    0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0,                                                                   // 61
+    0x00, 0x00, 0x10, 0x01, 0xA0, 0x00, 0xA0, 0x00, 0x40,                                                                   // 62
+    0x10, 0x00, 0x08, 0x00, 0x08, 0x00, 0xC8, 0x02, 0x48, 0x00, 0x30,                                                       // 63
+    0x00, 0x00, 0xC0, 0x03, 0x30, 0x04, 0xD0, 0x09, 0x28, 0x0A, 0x28, 0x0A, 0xC8, 0x0B, 0x68, 0x0A, 0x10, 0x05, 0xE0, 0x04, // 64
+    0x00, 0x02, 0xC0, 0x01, 0xB0, 0x00, 0x88, 0x00, 0xB0, 0x00, 0xC0, 0x01, 0x00, 0x02,                                     // 65
+    0x00, 0x00, 0xF8, 0x03, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0xF0, 0x01,                                                 // 66
+    0x00, 0x00, 0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0x10, 0x01,                                                 // 67
+    0x00, 0x00, 0xF8, 0x03, 0x08, 0x02, 0x08, 0x02, 0x10, 0x01, 0xE0,                                                       // 68
+    0x00, 0x00, 0xF8, 0x03, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02,                                                 // 69
+    0x00, 0x00, 0xF8, 0x03, 0x48, 0x00, 0x48, 0x00, 0x08,                                                                   // 70
+    0x00, 0x00, 0xE0, 0x00, 0x10, 0x01, 0x08, 0x02, 0x48, 0x02, 0x50, 0x01, 0xC0,                                           // 71
+    0x00, 0x00, 0xF8, 0x03, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xF8, 0x03,                                                 // 72
+    0x00, 0x00, 0xF8, 0x03,                                                                                                 // 73
+    0x00, 0x03, 0x00, 0x02, 0x00, 0x02, 0xF8, 0x01,                                                                         // 74
+    0x00, 0x00, 0xF8, 0x03, 0x80, 0x00, 0x60, 0x00, 0x90, 0x00, 0x08, 0x01, 0x00, 0x02,                                     // 75
+    0x00, 0x00, 0xF8, 0x03, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02,                                                 // 76
+    0x00, 0x00, 0xF8, 0x03, 0x30, 0x00, 0xC0, 0x01, 0x00, 0x02, 0xC0, 0x01, 0x30, 0x00, 0xF8, 0x03,                         // 77
+    0x00, 0x00, 0xF8, 0x03, 0x30, 0x00, 0x40, 0x00, 0x80, 0x01, 0xF8, 0x03,                                                 // 78
+    0x00, 0x00, 0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0xF0, 0x01,                                     // 79
+    0x00, 0x00, 0xF8, 0x03, 0x48, 0x00, 0x48, 0x00, 0x48, 0x00, 0x30,                                                       // 80
+    0x00, 0x00, 0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x03, 0x08, 0x03, 0xF0, 0x02,                                     // 81
+    0x00, 0x00, 0xF8, 0x03, 0x48, 0x00, 0x48, 0x00, 0xC8, 0x00, 0x30, 0x03,                                                 // 82
+    0x00, 0x00, 0x30, 0x01, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0x90, 0x01,                                                 // 83
+    0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x03, 0x08, 0x00, 0x08,                                                       // 84
+    0x00, 0x00, 0xF8, 0x01, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0xF8, 0x01,                                                 // 85
+    0x08, 0x00, 0x70, 0x00, 0x80, 0x01, 0x00, 0x02, 0x80, 0x01, 0x70, 0x00, 0x08,                                           // 86
+    0x18, 0x00, 0xE0, 0x01, 0x00, 0x02, 0xF0, 0x01, 0x08, 0x00, 0xF0, 0x01, 0x00, 0x02, 0xE0, 0x01, 0x18,                   // 87
+    0x00, 0x02, 0x08, 0x01, 0x90, 0x00, 0x60, 0x00, 0x90, 0x00, 0x08, 0x01, 0x00, 0x02,                                     // 88
+    0x08, 0x00, 0x10, 0x00, 0x20, 0x00, 0xC0, 0x03, 0x20, 0x00, 0x10, 0x00, 0x08,                                           // 89
+    0x08, 0x03, 0x88, 0x02, 0xC8, 0x02, 0x68, 0x02, 0x38, 0x02, 0x18, 0x02,                                                 // 90
+    0x00, 0x00, 0xF8, 0x0F, 0x08, 0x08,                                                                                     // 91
+    0x18, 0x00, 0xE0, 0x00, 0x00, 0x03,                                                                                     // 92
+    0x08, 0x08, 0xF8, 0x0F,                                                                                                 // 93
+    0x40, 0x00, 0x30, 0x00, 0x08, 0x00, 0x30, 0x00, 0x40,                                                                   // 94
+    0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08,                                                 // 95
+    0x08, 0x00, 0x10,                                                                                                       // 96
+    0x00, 0x00, 0x00, 0x03, 0xA0, 0x02, 0xA0, 0x02, 0xE0, 0x03,                                                             // 97
+    0x00, 0x00, 0xF8, 0x03, 0x20, 0x02, 0x20, 0x02, 0xC0, 0x01,                                                             // 98
+    0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0x40, 0x01,                                                             // 99
+    0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0xF8, 0x03,                                                             // 100
+    0x00, 0x00, 0xC0, 0x01, 0xA0, 0x02, 0xA0, 0x02, 0xC0, 0x02,                                                             // 101
+    0x20, 0x00, 0xF0, 0x03, 0x28,                                                                                           // 102
+    0x00, 0x00, 0xC0, 0x05, 0x20, 0x0A, 0x20, 0x0A, 0xE0, 0x07,                                                             // 103
+    0x00, 0x00, 0xF8, 0x03, 0x20, 0x00, 0x20, 0x00, 0xC0, 0x03,                                                             // 104
+    0x00, 0x00, 0xE8, 0x03,                                                                                                 // 105
+    0x00, 0x08, 0xE8, 0x07,                                                                                                 // 106
+    0xF8, 0x03, 0x80, 0x00, 0xC0, 0x01, 0x20, 0x02,                                                                         // 107
+    0x00, 0x00, 0xF8, 0x03,                                                                                                 // 108
+    0x00, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20, 0x00, 0xC0, 0x03,                         // 109
+    0x00, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20, 0x00, 0xC0, 0x03,                                                             // 110
+    0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0xC0, 0x01,                                                             // 111
+    0x00, 0x00, 0xE0, 0x0F, 0x20, 0x02, 0x20, 0x02, 0xC0, 0x01,                                                             // 112
+    0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0xE0, 0x0F,                                                             // 113
+    0x00, 0x00, 0xE0, 0x03, 0x20,                                                                                           // 114
+    0x40, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0x20, 0x01,                                                                         // 115
+    0x20, 0x00, 0xF8, 0x03, 0x20, 0x02,                                                                                     // 116
+    0x00, 0x00, 0xE0, 0x01, 0x00, 0x02, 0x00, 0x02, 0xE0, 0x03,                                                             // 117
+    0x20, 0x00, 0xC0, 0x01, 0x00, 0x02, 0xC0, 0x01, 0x20,                                                                   // 118
+    0xE0, 0x01, 0x00, 0x02, 0xC0, 0x01, 0x20, 0x00, 0xC0, 0x01, 0x00, 0x02, 0xE0, 0x01,                                     // 119
+    0x20, 0x02, 0x40, 0x01, 0x80, 0x00, 0x40, 0x01, 0x20, 0x02,                                                             // 120
+    0x20, 0x00, 0xC0, 0x09, 0x00, 0x06, 0xC0, 0x01, 0x20,                                                                   // 121
+    0x20, 0x02, 0x20, 0x03, 0xA0, 0x02, 0x60, 0x02, 0x20, 0x02,                                                             // 122
+    0x80, 0x00, 0x78, 0x0F, 0x08, 0x08,                                                                                     // 123
+    0x00, 0x00, 0xF8, 0x0F,                                                                                                 // 124
+    0x08, 0x08, 0x78, 0x0F, 0x80,                                                                                           // 125
+    0xC0, 0x00, 0x40, 0x00, 0xC0, 0x00, 0x80, 0x00, 0xC0,                                                                   // 126
+    0x00, 0x00, 0xA0, 0x0F,                                                                                                 // 161
+    0x00, 0x00, 0xC0, 0x01, 0xA0, 0x0F, 0x78, 0x02, 0x40, 0x01,                                                             // 162
+    0x40, 0x02, 0x70, 0x03, 0xC8, 0x02, 0x48, 0x02, 0x08, 0x02, 0x10, 0x02,                                                 // 163
+    0x00, 0x00, 0xE0, 0x01, 0x20, 0x01, 0x20, 0x01, 0xE0, 0x01,                                                             // 164
+    0x00, 0x00, 0xF8, 0x03, 0x08, 0x00, 0x08, 0x00, 0x0C,                                                                   // 165
+    0x00, 0x00, 0x38, 0x0F,                                                                                                 // 166
+    0xD0, 0x04, 0x28, 0x09, 0x48, 0x09, 0x48, 0x0A, 0x90, 0x05,                                                             // 167
+    0x00, 0x00, 0xE0, 0x03, 0xA8, 0x02, 0xA0, 0x02, 0xA8, 0x02, 0x20, 0x02,                                                 // 168
+    0xE0, 0x00, 0x10, 0x01, 0x48, 0x02, 0xA8, 0x02, 0xA8, 0x02, 0x10, 0x01, 0xE0,                                           // 169
+    0x00, 0x00, 0xF0, 0x01, 0x58, 0x03, 0x48, 0x02, 0x08, 0x02, 0x10, 0x01,                                                 // 170
+    0x00, 0x00, 0x80, 0x01, 0x40, 0x02, 0x80, 0x01, 0x40, 0x02,                                                             // 171
+    0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0xE0,                                                                   // 172
+    0x80, 0x00, 0x80,                                                                                                       // 173
+    0xE0, 0x00, 0x10, 0x01, 0xE8, 0x02, 0x68, 0x02, 0xC8, 0x02, 0x10, 0x01, 0xE0,                                           // 174
+    0x00, 0x00, 0x08, 0x02, 0x0A, 0x02, 0xF8, 0x03, 0x0A, 0x02, 0x08, 0x02,                                                 // 175
+    0x00, 0x00, 0x38, 0x00, 0x28, 0x00, 0x38,                                                                               // 176
+    0x40, 0x02, 0x40, 0x02, 0xF0, 0x03, 0x40, 0x02, 0x40, 0x02,                                                             // 177
+    0x00, 0x00, 0x08, 0x02, 0x08, 0x02, 0xF8, 0x03, 0x08, 0x02, 0x08, 0x02,                                                 // 178
+    0x00, 0x00, 0x20, 0x02, 0x20, 0x02, 0xE8, 0x03, 0x20, 0x02, 0x20, 0x02,                                                 // 179
+    0x00, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x30,                                                                               // 180
+    0x00, 0x00, 0xE0, 0x0F, 0x00, 0x02, 0x00, 0x02, 0xE0, 0x03,                                                             // 181
+    0x70, 0x00, 0xF8, 0x0F, 0x08, 0x00, 0xF8, 0x0F, 0x08,                                                                   // 182
+    0x00, 0x00, 0x40,                                                                                                       // 183
+    0x00, 0x00, 0xC0, 0x01, 0xA8, 0x02, 0xA0, 0x02, 0xA8, 0x02, 0xC0,                                                       // 184
+    0x00, 0x00, 0xF0, 0x03, 0x40, 0x00, 0x80, 0x00, 0xF8, 0x03, 0x08,                                                       // 185
+    0x00, 0x00, 0xE0, 0x01, 0x50, 0x02, 0x50, 0x02, 0x10, 0x02, 0x20, 0x01,                                                 // 186
+    0x00, 0x00, 0x40, 0x02, 0x80, 0x01, 0x40, 0x02, 0x80, 0x01,                                                             // 187
+    0x00, 0x00, 0x10, 0x02, 0x78, 0x01, 0xC0, 0x00, 0x20, 0x01, 0x90, 0x01, 0xC8, 0x03, 0x00, 0x01,                         // 188
+    0x00, 0x00, 0x10, 0x02, 0x78, 0x01, 0x80, 0x00, 0x60, 0x00, 0x50, 0x02, 0x48, 0x03, 0xC0, 0x02,                         // 189
+    0x48, 0x00, 0x58, 0x00, 0x68, 0x03, 0x80, 0x00, 0x60, 0x01, 0x90, 0x01, 0xC8, 0x03, 0x00, 0x01,                         // 190
+    0x00, 0x00, 0x00, 0x00, 0x28, 0x02, 0xE0, 0x03, 0x28, 0x02,                                                             // 191
+    0x00, 0x00, 0xF0, 0x03, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0xF0, 0x03,                                                 // 192
+    0x00, 0x00, 0xF8, 0x03, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0x88, 0x01,                                                 // 193
+    0x00, 0x00, 0xF8, 0x03, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0xB0, 0x01,                                                 // 194
+    0x00, 0x00, 0xF8, 0x03, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x18,                                                       // 195
+    0x00, 0x00, 0x00, 0x02, 0xFC, 0x03, 0x04, 0x02, 0xFC, 0x03, 0x00, 0x02,                                                 // 196
+    0x00, 0x00, 0xF8, 0x03, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0x08, 0x02,                                                 // 197
+    0x00, 0x00, 0xB8, 0x03, 0x40, 0x00, 0xF8, 0x03, 0x40, 0x00, 0xB8, 0x03,                                                 // 198
+    0x00, 0x00, 0x08, 0x02, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0xB0, 0x01,                                                 // 199
+    0x00, 0x00, 0xF8, 0x03, 0x80, 0x00, 0x40, 0x00, 0x20, 0x00, 0xF8, 0x03,                                                 // 200
+    0x00, 0x00, 0xE0, 0x03, 0x08, 0x01, 0x90, 0x00, 0x48, 0x00, 0xE0, 0x03,                                                 // 201
+    0x00, 0x00, 0xF8, 0x03, 0x40, 0x00, 0xA0, 0x00, 0x10, 0x01, 0x08, 0x02,                                                 // 202
+    0x00, 0x00, 0x00, 0x02, 0xF0, 0x01, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x03,                                                 // 203
+    0x00, 0x00, 0xF8, 0x03, 0x10, 0x00, 0x60, 0x00, 0x10, 0x00, 0xF8, 0x03,                                                 // 204
+    0x00, 0x00, 0xF8, 0x03, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xF8, 0x03,                                                 // 205
+    0x00, 0x00, 0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0xF0, 0x01,                                                 // 206
+    0x00, 0x00, 0xF8, 0x03, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x03,                                                 // 207
+    0x00, 0x00, 0xF8, 0x03, 0x48, 0x00, 0x48, 0x00, 0x48, 0x00, 0x30,                                                       // 208
+    0x00, 0x00, 0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0x10, 0x01,                                                 // 209
+    0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x03, 0x08, 0x00, 0x08,                                                       // 210
+    0x00, 0x00, 0x38, 0x00, 0x40, 0x02, 0x40, 0x02, 0x40, 0x02, 0xF8, 0x01,                                                 // 211
+    0x00, 0x00, 0x70, 0x00, 0x88, 0x00, 0xF8, 0x03, 0x88, 0x00, 0x70,                                                       // 212
+    0x00, 0x00, 0x18, 0x03, 0xA0, 0x00, 0x40, 0x00, 0xA0, 0x00, 0x18, 0x03,                                                 // 213
+    0x00, 0x00, 0xF8, 0x03, 0x00, 0x02, 0x00, 0x02, 0xF8, 0x03, 0x00, 0x02,                                                 // 214
+    0x00, 0x00, 0x38, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xF8, 0x03,                                                 // 215
+    0x00, 0x00, 0xF8, 0x03, 0x00, 0x02, 0xF8, 0x03, 0x00, 0x02, 0xF8, 0x03,                                                 // 216
+    0x00, 0x00, 0xF8, 0x03, 0x00, 0x02, 0xF8, 0x03, 0x00, 0x02, 0xF8, 0x03, 0x00, 0x06,                                     // 217
+    0x00, 0x00, 0x08, 0x00, 0xF8, 0x03, 0x40, 0x02, 0x40, 0x02, 0x80, 0x01,                                                 // 218
+    0x00, 0x00, 0xF8, 0x03, 0x40, 0x02, 0x40, 0x02, 0x80, 0x01, 0xF8, 0x03,                                                 // 219
+    0x00, 0x00, 0xF8, 0x03, 0x40, 0x02, 0x40, 0x02, 0x40, 0x02, 0x80, 0x01,                                                 // 220
+    0x00, 0x00, 0x10, 0x01, 0x08, 0x02, 0x48, 0x02, 0x48, 0x02, 0xF0, 0x01,                                                 // 221
+    0x00, 0x00, 0xF8, 0x03, 0x40, 0x00, 0xF0, 0x01, 0x08, 0x02, 0xF0, 0x01,                                                 // 222
+    0x00, 0x00, 0x30, 0x02, 0x48, 0x01, 0xC8, 0x00, 0x48, 0x00, 0xF8, 0x03,                                                 // 223
+    0x00, 0x00, 0x00, 0x01, 0xA0, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0xC0, 0x03,                                                 // 224
+    0x00, 0x00, 0xE0, 0x01, 0x50, 0x02, 0x50, 0x02, 0x48, 0x02, 0x88, 0x01,                                                 // 225
+    0x00, 0x00, 0xE0, 0x03, 0xA0, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0x40, 0x01,                                                 // 226
+    0x00, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x60,                                                       // 227
+    0x00, 0x00, 0x00, 0x02, 0xC0, 0x03, 0x20, 0x02, 0xE0, 0x03, 0x00, 0x02,                                                 // 228
+    0x00, 0x00, 0xC0, 0x01, 0xA0, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0xC0,                                                       // 229
+    0x00, 0x00, 0x60, 0x03, 0x80, 0x00, 0xE0, 0x03, 0x80, 0x00, 0x60, 0x03,                                                 // 230
+    0x00, 0x00, 0x20, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0x40, 0x01,                                                 // 231
+    0x00, 0x00, 0xE0, 0x03, 0x00, 0x01, 0x80, 0x00, 0x40, 0x00, 0xE0, 0x03,                                                 // 232
+    0x00, 0x00, 0xE0, 0x03, 0x00, 0x01, 0x98, 0x00, 0x40, 0x00, 0xE0, 0x03,                                                 // 233
+    0x00, 0x00, 0xE0, 0x03, 0x80, 0x00, 0x80, 0x00, 0x40, 0x01, 0x20, 0x02,                                                 // 234
+    0x00, 0x00, 0x00, 0x02, 0xC0, 0x01, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x03,                                                 // 235
+    0x00, 0x00, 0xE0, 0x03, 0x40, 0x00, 0x80, 0x00, 0x40, 0x00, 0xE0, 0x03,                                                 // 236
+    0x00, 0x00, 0xE0, 0x03, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0xE0, 0x03,                                                 // 237
+    0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0x20, 0x02, 0xC0, 0x01,                                                 // 238
+    0x00, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x03,                                                 // 239
+    0x00, 0x00, 0xE0, 0x03, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0x40,                                                       // 240
+    0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0x20, 0x02, 0x40, 0x02,                                                 // 241
+    0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20,                                                       // 242
+    0x00, 0x00, 0x60, 0x00, 0x80, 0x02, 0x80, 0x02, 0x80, 0x02, 0xE0, 0x01,                                                 // 243
+    0x00, 0x00, 0xC0, 0x00, 0x20, 0x01, 0xE0, 0x03, 0x20, 0x01, 0xC0,                                                       // 244
+    0x00, 0x00, 0x20, 0x02, 0x40, 0x01, 0x80, 0x00, 0x40, 0x01, 0x20, 0x02,                                                 // 245
+    0x00, 0x00, 0xE0, 0x03, 0x00, 0x02, 0x00, 0x02, 0xE0, 0x03, 0x00, 0x02,                                                 // 246
+    0x00, 0x00, 0x60, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0xE0, 0x03,                                                 // 247
+    0x00, 0x00, 0xE0, 0x03, 0x00, 0x02, 0xE0, 0x03, 0x00, 0x02, 0xE0, 0x03,                                                 // 248
+    0x00, 0x00, 0xE0, 0x03, 0x00, 0x02, 0xE0, 0x03, 0x00, 0x02, 0xE0, 0x03, 0x00, 0x06,                                     // 249
+    0x00, 0x00, 0x20, 0x00, 0xE0, 0x03, 0x80, 0x02, 0x80, 0x02, 0x00, 0x01,                                                 // 250
+    0x00, 0x00, 0xE0, 0x03, 0x80, 0x02, 0x80, 0x02, 0x00, 0x01, 0xE0, 0x03,                                                 // 251
+    0x00, 0x00, 0xE0, 0x03, 0x80, 0x02, 0x80, 0x02, 0x80, 0x02, 0x00, 0x01,                                                 // 252
+    0x00, 0x00, 0x40, 0x01, 0x20, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0xC0, 0x01,                                                 // 253
+    0x00, 0x00, 0xE0, 0x03, 0x80, 0x00, 0xC0, 0x01, 0x20, 0x02, 0xC0, 0x01,                                                 // 254
+    0x00, 0x00, 0x40, 0x02, 0xA0, 0x01, 0xA0, 0x00, 0xA0, 0x00, 0xE0, 0x03,                                                 // 255
+};

src/graphics/fonts/OLEDDisplayFontsUA.h

@@ -0,0 +1,11 @@
+#ifndef OLEDDISPLAYFONTSUA_h
+#define OLEDDISPLAYFONTSUA_h
+
+#ifdef ARDUINO
+#include <Arduino.h>
+#elif __MBED__
+#define PROGMEM
+#endif
+
+extern const uint8_t ArialMT_Plain_10_UA[] PROGMEM;
+#endif

src/main.cpp

@@ -33,6 +33,12 @@
 #ifdef ARCH_ESP32
 #include "mesh/http/WebServer.h"
 #include "nimble/NimbleBluetooth.h"
+NimbleBluetooth *nimbleBluetooth;
+#endif
+
+#ifdef ARCH_NRF52
+#include "NRF52Bluetooth.h"
+NRF52Bluetooth *nrf52Bluetooth;
 #endif
 
 #if HAS_WIFI
@@ -270,7 +276,6 @@ void setup()
         LOG_INFO("PCF8563 RTC found\n");
     }
 #endif
-
     // We need to scan here to decide if we have a screen for nodeDB.init()
     scanI2Cdevice();
 
@@ -389,9 +394,22 @@ void setup()
 
     // radio init MUST BE AFTER service.init, so we have our radio config settings (from nodedb init)
 
+#if !HAS_RADIO && defined(ARCH_PORTDUINO)
+    if (!rIf) {
+        rIf = new SimRadio;
+        if (!rIf->init()) {
+            LOG_WARN("Failed to find simulated radio\n");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("Using SIMULATED radio!\n");
+        }
+    }
+#endif
+
 #if defined(RF95_IRQ)
     if (!rIf) {
-        rIf = new RF95Interface(RF95_NSS, RF95_IRQ, RF95_RESET, SPI);
+        rIf = new RF95Interface(RF95_NSS, RF95_IRQ, RF95_RESET, RF95_DIO1, SPI);
         if (!rIf->init()) {
             LOG_WARN("Failed to find RF95 radio\n");
             delete rIf;
@@ -402,19 +420,6 @@ void setup()
     }
 #endif
 
-#if defined(USE_SX1280)
-    if (!rIf) {
-        rIf = new SX1280Interface(SX128X_CS, SX128X_DIO1, SX128X_RESET, SX128X_BUSY, SPI);
-        if (!rIf->init()) {
-            LOG_WARN("Failed to find SX1280 radio\n");
-            delete rIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("SX1280 Radio init succeeded, using SX1280 radio\n");
-        }
-    }
-#endif
-
 #if defined(USE_SX1262)
     if (!rIf) {
         rIf = new SX1262Interface(SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY, SPI);
@@ -454,15 +459,15 @@ void setup()
     }
 #endif
 
-#ifdef ARCH_PORTDUINO
+#if defined(USE_SX1280)
     if (!rIf) {
-        rIf = new SimRadio;
+        rIf = new SX1280Interface(SX128X_CS, SX128X_DIO1, SX128X_RESET, SX128X_BUSY, SPI);
         if (!rIf->init()) {
-            LOG_WARN("Failed to find simulated radio\n");
+            LOG_WARN("Failed to find SX1280 radio\n");
             delete rIf;
             rIf = NULL;
         } else {
-            LOG_INFO("Using SIMULATED radio!\n");
+            LOG_INFO("SX1280 Radio init succeeded, using SX1280 radio\n");
         }
     }
 #endif
@@ -532,6 +537,21 @@ uint32_t shutdownAtMsec; // If not zero we will shutdown at this time (used to s
 // This will supress the current delay and instead try to run ASAP.
 bool runASAP;
 
+extern meshtastic_DeviceMetadata getDeviceMetadata()
+{
+    meshtastic_DeviceMetadata deviceMetadata;
+    strncpy(deviceMetadata.firmware_version, myNodeInfo.firmware_version, 18);
+    deviceMetadata.device_state_version = DEVICESTATE_CUR_VER;
+    deviceMetadata.canShutdown = pmu_found || HAS_CPU_SHUTDOWN;
+    deviceMetadata.hasBluetooth = HAS_BLUETOOTH;
+    deviceMetadata.hasWifi = HAS_WIFI;
+    deviceMetadata.hasEthernet = HAS_ETHERNET;
+    deviceMetadata.role = config.device.role;
+    deviceMetadata.position_flags = config.position.position_flags;
+    deviceMetadata.hw_model = HW_VENDOR;
+    return deviceMetadata;
+}
+
 void loop()
 {
     runASAP = false;

src/main.h

@@ -9,6 +9,14 @@
 #if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
 #include <SparkFun_ATECCX08a_Arduino_Library.h>
 #endif
+#if defined(ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32S2)
+#include "nimble/NimbleBluetooth.h"
+extern NimbleBluetooth *nimbleBluetooth;
+#endif
+#ifdef ARCH_NRF52
+#include "NRF52Bluetooth.h"
+extern NRF52Bluetooth *nrf52Bluetooth;
+#endif
 
 extern uint8_t screen_found;
 extern uint8_t screen_model;
@@ -53,3 +61,5 @@ extern uint32_t serialSinceMsec;
 extern bool runASAP;
 
 void nrf52Setup(), esp32Setup(), nrf52Loop(), esp32Loop(), clearBonds();
+
+meshtastic_DeviceMetadata getDeviceMetadata();

src/mesh/FloodingRouter.cpp

@@ -59,11 +59,6 @@ void FloodingRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
             LOG_DEBUG("Ignoring a simple (0 id) broadcast\n");
         }
     }
-
-    if (config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_LOCAL_ONLY) {
-        LOG_DEBUG("Cancelling rebroadcast of message from node on a foreign mesh, due to local only rebroadcast mode\n");
-        Router::cancelSending(p->to, p->decoded.request_id);
-    }
     // handle the packet as normal
     Router::sniffReceived(p, c);
 }

src/mesh/MeshModule.cpp

@@ -77,6 +77,8 @@ void MeshModule::callPlugins(const meshtastic_MeshPacket &mp, RxSource src)
 
     currentReply = NULL; // No reply yet
 
+    bool ignoreRequest = false; // No module asked to ignore the request yet
+
     // Was this message directed to us specifically?  Will be false if we are sniffing someone elses packets
     auto ourNodeNum = nodeDB.getNodeNum();
     bool toUs = mp.to == NODENUM_BROADCAST || mp.to == ourNodeNum;
@@ -135,7 +137,8 @@ void MeshModule::callPlugins(const meshtastic_MeshPacket &mp, RxSource src)
                 // any other node.
                 if (mp.decoded.want_response && toUs && (getFrom(&mp) != ourNodeNum || mp.to == ourNodeNum) && !currentReply) {
                     pi.sendResponse(mp);
-                    LOG_INFO("Module '%s' sent a response\n", pi.name);
+                    ignoreRequest = ignoreRequest || pi.ignoreRequest; // If at least one module asks it, we may ignore a request
+                    LOG_INFO("Asked module '%s' to send a response\n", pi.name);
                 } else {
                     LOG_DEBUG("Module '%s' considered\n", pi.name);
                 }
@@ -162,8 +165,9 @@ void MeshModule::callPlugins(const meshtastic_MeshPacket &mp, RxSource src)
             printPacket("Sending response", currentReply);
             service.sendToMesh(currentReply);
             currentReply = NULL;
-        } else if (mp.from != ourNodeNum) {
-            // Note: if the message started with the local node we don't want to send a no response reply
+        } else if (mp.from != ourNodeNum && !ignoreRequest) {
+            // Note: if the message started with the local node or a module asked to ignore the request, we don't want to send a
+            // no response reply
 
             // No one wanted to reply to this requst, tell the requster that happened
             LOG_DEBUG("No one responded, send a nak\n");

src/mesh/MeshModule.h

@@ -94,6 +94,9 @@ class MeshModule
      * flag */
     bool encryptedOk = false;
 
+    /* We allow modules to ignore a request without sending an error if they have a specific reason for it. */
+    bool ignoreRequest = false;
+
     /** If a bound channel name is set, we will only accept received packets that come in on that channel.
      * A special exception (FIXME, not sure if this is a good idea) - packets that arrive on the local interface
      * are allowed on any channel (this lets the local user do anything).

src/mesh/MeshService.cpp

@@ -75,9 +75,13 @@ int MeshService::handleFromRadio(const meshtastic_MeshPacket *mp)
 {
     powerFSM.trigger(EVENT_PACKET_FOR_PHONE); // Possibly keep the node from sleeping
 
-    printPacket("Forwarding to phone", mp);
     nodeDB.updateFrom(*mp); // update our DB state based off sniffing every RX packet from the radio
+    if (!nodeDB.getNode(mp->from)->has_user && nodeInfoModule) {
+        LOG_INFO("Heard a node we don't know, sending NodeInfo and asking for a response.\n");
+        nodeInfoModule->sendOurNodeInfo(mp->from, true);
+    }
 
+    printPacket("Forwarding to phone", mp);
     sendToPhone((meshtastic_MeshPacket *)mp);
 
     return 0;
@@ -132,7 +136,7 @@ void MeshService::reloadOwner(bool shouldSave)
  */
 void MeshService::handleToRadio(meshtastic_MeshPacket &p)
 {
-#ifdef ARCH_PORTDUINO
+#if defined(ARCH_PORTDUINO) && !HAS_RADIO
     // Simulates device is receiving a packet via the LoRa chip
     if (p.decoded.portnum == meshtastic_PortNum_SIMULATOR_APP) {
         // Simulator packet (=Compressed packet) is encapsulated in a MeshPacket, so need to unwrap first

src/mesh/MeshService.h

@@ -10,7 +10,7 @@
 #include "MeshTypes.h"
 #include "Observer.h"
 #include "PointerQueue.h"
-#ifdef ARCH_PORTDUINO
+#if defined(ARCH_PORTDUINO) && !HAS_RADIO
 #include "../platform/portduino/SimRadio.h"
 #endif
 

src/mesh/NodeDB.cpp

@@ -170,6 +170,8 @@ void NodeDB::installDefaultConfig()
     config.lora.hop_limit = HOP_RELIABLE;
     config.position.gps_enabled = true;
     config.position.position_broadcast_smart_enabled = true;
+    if (config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER)
+        config.device.node_info_broadcast_secs = 3 * 60 * 60;
     config.device.serial_enabled = true;
     resetRadioConfig();
     strncpy(config.network.ntp_server, "0.pool.ntp.org", 32);
@@ -233,15 +235,13 @@ void NodeDB::installRoleDefaults(meshtastic_Config_DeviceConfig_Role role)
         initModuleConfigIntervals();
     } else if (role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
         config.display.screen_on_secs = 1;
-        meshtastic_Channel &ch = channels.getByIndex(channels.getPrimaryIndex());
-        meshtastic_ChannelSettings &channelSettings = ch.settings;
-        uint8_t defaultpskIndex = 1;
-        channelSettings.psk.bytes[0] = defaultpskIndex;
-        channelSettings.psk.size = 1;
     } else if (role == meshtastic_Config_DeviceConfig_Role_TRACKER) {
         config.position.position_broadcast_smart_enabled = false;
         config.position.position_broadcast_secs = 120;
         config.position.gps_update_interval = 60;
+    } else if (role == meshtastic_Config_DeviceConfig_Role_SENSOR) {
+        moduleConfig.telemetry.environment_measurement_enabled = true;
+        moduleConfig.telemetry.environment_update_interval = 300;
     }
 }
 
@@ -249,6 +249,7 @@ void NodeDB::initModuleConfigIntervals()
 {
     moduleConfig.telemetry.device_update_interval = default_broadcast_interval_secs;
     moduleConfig.telemetry.environment_update_interval = default_broadcast_interval_secs;
+    moduleConfig.telemetry.air_quality_interval = default_broadcast_interval_secs;
 }
 
 void NodeDB::installDefaultChannels()
@@ -599,6 +600,17 @@ uint32_t sinceLastSeen(const meshtastic_NodeInfo *n)
     return delta;
 }
 
+uint32_t sinceReceived(const meshtastic_MeshPacket *p)
+{
+    uint32_t now = getTime();
+
+    int delta = (int)(now - p->rx_time);
+    if (delta < 0) // our clock must be slightly off still - not set from GPS yet
+        delta = 0;
+
+    return delta;
+}
+
 #define NUM_ONLINE_SECS (60 * 60 * 2) // 2 hrs to consider someone offline
 
 size_t NodeDB::getNumOnlineNodes()

src/mesh/NodeDB.h

@@ -32,6 +32,9 @@ extern meshtastic_User &owner;
 /// Given a node, return how many seconds in the past (vs now) that we last heard from it
 uint32_t sinceLastSeen(const meshtastic_NodeInfo *n);
 
+/// Given a packet, return how many seconds in the past (vs now) it was received
+uint32_t sinceReceived(const meshtastic_MeshPacket *p);
+
 class NodeDB
 {
     // NodeNum provisionalNodeNum; // if we are trying to find a node num this is our current attempt

src/mesh/PhoneAPI.cpp

@@ -6,6 +6,7 @@
 #include "PowerFSM.h"
 #include "RadioInterface.h"
 #include "configuration.h"
+#include "main.h"
 #include "xmodem.h"
 
 #if FromRadio_size > MAX_TO_FROM_RADIO_SIZE
@@ -120,6 +121,7 @@ bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
  *      STATE_SEND_NODEINFO, // states progress in this order as the device sends to the client
         STATE_SEND_CONFIG,
         STATE_SEND_MODULE_CONFIG,
+        STATE_SEND_METADATA,
         STATE_SEND_COMPLETE_ID,
         STATE_SEND_PACKETS // send packets or debug strings
  */
@@ -277,11 +279,15 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
         config_state++;
         // Advance when we have sent all of our ModuleConfig objects
         if (config_state > (_meshtastic_AdminMessage_ModuleConfigType_MAX + 1)) {
-            state = STATE_SEND_COMPLETE_ID;
+            state = STATE_SEND_METADATA;
             config_state = 0;
         }
         break;
-
+    case STATE_SEND_METADATA:
+        fromRadioScratch.which_payload_variant = meshtastic_FromRadio_metadata_tag;
+        fromRadioScratch.metadata = getDeviceMetadata();
+        state = STATE_SEND_COMPLETE_ID;
+        break;
     case STATE_SEND_COMPLETE_ID:
         LOG_INFO("getFromRadio=STATE_SEND_COMPLETE_ID\n");
         fromRadioScratch.which_payload_variant = meshtastic_FromRadio_config_complete_id_tag;
@@ -361,6 +367,7 @@ bool PhoneAPI::available()
     case STATE_SEND_CHANNELS:
     case STATE_SEND_CONFIG:
     case STATE_SEND_MODULECONFIG:
+    case STATE_SEND_METADATA:
     case STATE_SEND_COMPLETE_ID:
         return true;
 

src/mesh/PhoneAPI.h

@@ -26,6 +26,7 @@ class PhoneAPI
         STATE_SEND_CHANNELS,     // Send all channels
         STATE_SEND_CONFIG,       // Replacement for the old Radioconfig
         STATE_SEND_MODULECONFIG, // Send Module specific config
+        STATE_SEND_METADATA,
         STATE_SEND_COMPLETE_ID,
         STATE_SEND_PACKETS // send packets or debug strings
     };

src/mesh/RF95Interface.cpp

@@ -11,8 +11,9 @@
 
 #define POWER_DEFAULT 17 // How much power to use if the user hasn't set a power level
 
-RF95Interface::RF95Interface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, SPIClass &spi)
-    : RadioLibInterface(cs, irq, rst, RADIOLIB_NC, spi)
+RF95Interface::RF95Interface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy,
+                             SPIClass &spi)
+    : RadioLibInterface(cs, irq, rst, busy, spi)
 {
     // FIXME - we assume devices never get destroyed
 }
@@ -67,19 +68,12 @@ bool RF95Interface::init()
 #endif
     setTransmitEnable(false);
 
-    int res = lora->begin(getFreq(), bw, sf, cr, syncWord, power, currentLimit, preambleLength);
+    int res = lora->begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength);
     LOG_INFO("RF95 init result %d\n", res);
-
     LOG_INFO("Frequency set to %f\n", getFreq());
     LOG_INFO("Bandwidth set to %f\n", bw);
     LOG_INFO("Power output set to %d\n", power);
 
-    // current limit was removed from module' ctor
-    // override default value (60 mA)
-    res = lora->setCurrentLimit(currentLimit);
-    LOG_DEBUG("Current limit set to %f\n", currentLimit);
-    LOG_DEBUG("Current limit set result %d\n", res);
-
     if (res == RADIOLIB_ERR_NONE)
         res = lora->setCRC(RADIOLIB_SX126X_LORA_CRC_ON);
 

src/mesh/RF95Interface.h

@@ -12,7 +12,7 @@ class RF95Interface : public RadioLibInterface
     RadioLibRF95 *lora = NULL; // Either a RFM95 or RFM96 depending on what was stuffed on this board
 
   public:
-    RF95Interface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, SPIClass &spi);
+    RF95Interface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy, SPIClass &spi);
 
     // TODO: Verify that this irq flag works with RFM95 / SX1276 radios the way it used to
     bool isIRQPending() override { return lora->getIRQFlags() & RADIOLIB_SX127X_MASK_IRQ_FLAG_VALID_HEADER; }

src/mesh/RadioInterface.cpp

@@ -175,7 +175,7 @@ uint32_t RadioInterface::getPacketTime(uint32_t pl)
     return msecs;
 }
 
-uint32_t RadioInterface::getPacketTime(meshtastic_MeshPacket *p)
+uint32_t RadioInterface::getPacketTime(const meshtastic_MeshPacket *p)
 {
     uint32_t pl = 0;
     if (p->which_payload_variant == meshtastic_MeshPacket_encrypted_tag) {
@@ -227,7 +227,8 @@ uint32_t RadioInterface::getTxDelayMsecWeighted(float snr)
     uint8_t CWsize = map(snr, SNR_MIN, SNR_MAX, CWmin, CWmax);
     // LOG_DEBUG("rx_snr of %f so setting CWsize to:%d\n", snr, CWsize);
     if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
-        config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT) {
+        config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT ||
+        config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
         delay = random(0, 2 * CWsize) * slotTimeMsec;
         LOG_DEBUG("rx_snr found in packet. As a router, setting tx delay:%d\n", delay);
     } else {
@@ -240,47 +241,48 @@ uint32_t RadioInterface::getTxDelayMsecWeighted(float snr)
 
 void printPacket(const char *prefix, const meshtastic_MeshPacket *p)
 {
-    LOG_DEBUG("%s (id=0x%08x fr=0x%02x to=0x%02x, WantAck=%d, HopLim=%d Ch=0x%x", prefix, p->id, p->from & 0xff, p->to & 0xff,
-              p->want_ack, p->hop_limit, p->channel);
+    std::string out = DEBUG_PORT.mt_sprintf("%s (id=0x%08x fr=0x%02x to=0x%02x, WantAck=%d, HopLim=%d Ch=0x%x", prefix, p->id,
+                                            p->from & 0xff, p->to & 0xff, p->want_ack, p->hop_limit, p->channel);
     if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
         auto &s = p->decoded;
 
-        LOG_DEBUG(" Portnum=%d", s.portnum);
+        out += DEBUG_PORT.mt_sprintf(" Portnum=%d", s.portnum);
 
         if (s.want_response)
-            LOG_DEBUG(" WANTRESP");
+            out += DEBUG_PORT.mt_sprintf(" WANTRESP");
 
         if (s.source != 0)
-            LOG_DEBUG(" source=%08x", s.source);
+            out += DEBUG_PORT.mt_sprintf(" source=%08x", s.source);
 
         if (s.dest != 0)
-            LOG_DEBUG(" dest=%08x", s.dest);
+            out += DEBUG_PORT.mt_sprintf(" dest=%08x", s.dest);
 
         if (s.request_id)
-            LOG_DEBUG(" requestId=%0x", s.request_id);
+            out += DEBUG_PORT.mt_sprintf(" requestId=%0x", s.request_id);
 
         /* now inside Data and therefore kinda opaque
         if (s.which_ackVariant == SubPacket_success_id_tag)
-            LOG_DEBUG(" successId=%08x", s.ackVariant.success_id);
+            out += DEBUG_PORT.mt_sprintf(" successId=%08x", s.ackVariant.success_id);
         else if (s.which_ackVariant == SubPacket_fail_id_tag)
-            LOG_DEBUG(" failId=%08x", s.ackVariant.fail_id); */
+            out += DEBUG_PORT.mt_sprintf(" failId=%08x", s.ackVariant.fail_id); */
     } else {
-        LOG_DEBUG(" encrypted");
+        out += " encrypted";
     }
 
     if (p->rx_time != 0) {
-        LOG_DEBUG(" rxtime=%u", p->rx_time);
+        out += DEBUG_PORT.mt_sprintf(" rxtime=%u", p->rx_time);
     }
     if (p->rx_snr != 0.0) {
-        LOG_DEBUG(" rxSNR=%g", p->rx_snr);
+        out += DEBUG_PORT.mt_sprintf(" rxSNR=%g", p->rx_snr);
     }
     if (p->rx_rssi != 0) {
-        LOG_DEBUG(" rxRSSI=%i", p->rx_rssi);
+        out += DEBUG_PORT.mt_sprintf(" rxRSSI=%i", p->rx_rssi);
     }
     if (p->priority != 0)
-        LOG_DEBUG(" priority=%d", p->priority);
+        out += DEBUG_PORT.mt_sprintf(" priority=%d", p->priority);
 
-    LOG_DEBUG(")\n");
+    out + ")\n";
+    LOG_DEBUG("%s", out.c_str());
 }
 
 RadioInterface::RadioInterface()
@@ -460,10 +462,16 @@ void RadioInterface::applyModemConfig()
     // New frequency selection formula
     float freq = myRegion->freqStart + (bw / 2000) + (channel_num * (bw / 1000));
 
-    saveChannelNum(channel_num);
-    saveFreq(freq + config.lora.frequency_offset);
+    // override if we have a verbatim frequency
+    if (loraConfig.override_frequency) {
+        freq = loraConfig.override_frequency;
+        channel_num = -1;
+    }
 
-    LOG_INFO("Radio freq=%.3f, config.lora.frequency_offset=%.3f\n", freq, config.lora.frequency_offset);
+    saveChannelNum(channel_num);
+    saveFreq(freq + loraConfig.frequency_offset);
+
+    LOG_INFO("Radio freq=%.3f, config.lora.frequency_offset=%.3f\n", freq, loraConfig.frequency_offset);
     LOG_INFO("Set radio: region=%s, name=%s, config=%u, ch=%d, power=%d\n", myRegion->name, channelName, loraConfig.modem_preset,
              channel_num, power);
     LOG_INFO("Radio myRegion->freqStart -> myRegion->freqEnd: %f -> %f (%f mhz)\n", myRegion->freqStart, myRegion->freqEnd,

src/mesh/RadioInterface.h

@@ -63,7 +63,7 @@ class RadioInterface
       - Tx/Rx turnaround time (maximum of SX126x and SX127x);
       - MAC processing time (measured on T-beam) */
     uint32_t slotTimeMsec = 8.5 * pow(2, sf) / bw + 0.2 + 0.4 + 7;
-    uint16_t preambleLength = 32; // 8 is default, but we use longer to increase the amount of sleep time when receiving
+    uint16_t preambleLength = 16; // 8 is default, but we use longer to increase the amount of sleep time when receiving
     const uint32_t PROCESSING_TIME_MSEC =
         4500;                // time to construct, process and construct a packet again (empirically determined)
     const uint8_t CWmin = 2; // minimum CWsize
@@ -154,7 +154,7 @@ class RadioInterface
      *
      * @return num msecs for the packet
      */
-    uint32_t getPacketTime(meshtastic_MeshPacket *p);
+    uint32_t getPacketTime(const meshtastic_MeshPacket *p);
     uint32_t getPacketTime(uint32_t totalPacketLen);
 
     /**

src/mesh/RadioLibInterface.cpp

@@ -108,20 +108,15 @@ ErrorCode RadioLibInterface::send(meshtastic_MeshPacket *p)
 
     if (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
         if (disabled || !config.lora.tx_enabled) {
-
-            if (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
-                if (disabled || !config.lora.tx_enabled) {
-                    LOG_WARN("send - !config.lora.tx_enabled\n");
-                    packetPool.release(p);
-                    return ERRNO_DISABLED;
-                }
-
-            } else {
-                LOG_WARN("send - lora tx disable because RegionCode_Unset\n");
-                packetPool.release(p);
-                return ERRNO_DISABLED;
-            }
+            LOG_WARN("send - !config.lora.tx_enabled\n");
+            packetPool.release(p);
+            return ERRNO_DISABLED;
         }
+
+    } else {
+        LOG_WARN("send - lora tx disable because RegionCode_Unset\n");
+        packetPool.release(p);
+        return ERRNO_DISABLED;
     }
 
 #else
@@ -223,8 +218,9 @@ void RadioLibInterface::onNotify(uint32_t notification)
                 setTransmitDelay(); // currently Rx/Tx-ing: reset random delay
             } else {
                 if (isChannelActive()) { // check if there is currently a LoRa packet on the channel
-                    // LOG_DEBUG("Channel is active: set random delay\n");
-                    setTransmitDelay(); // reset random delay
+                    // LOG_DEBUG("Channel is active, try receiving first.\n");
+                    startReceive(); // try receiving this packet, afterwards we'll be trying to transmit again
+                    setTransmitDelay();
                 } else {
                     // Send any outgoing packets we have ready
                     meshtastic_MeshPacket *txp = txQueue.dequeue();
@@ -393,8 +389,6 @@ void RadioLibInterface::startSend(meshtastic_MeshPacket *txp)
         LOG_WARN("startSend is dropping tx packet because we are disabled\n");
         packetPool.release(txp);
     } else {
-        setStandby(); // Cancel any already in process receives
-
         configHardwareForSend(); // must be after setStandby
 
         size_t numbytes = beginSending(txp);

src/mesh/ReliableRouter.cpp

@@ -24,6 +24,15 @@ ErrorCode ReliableRouter::send(meshtastic_MeshPacket *p)
         startRetransmission(copy);
     }
 
+    /* If we have pending retransmissions, add the airtime of this packet to it, because during that time we cannot receive an
+       (implicit) ACK. Otherwise, we might retransmit too early.
+     */
+    for (auto i = pending.begin(); i != pending.end(); i++) {
+        if (i->first.id != p->id) {
+            i->second.nextTxMsec += iface->getPacketTime(p);
+        }
+    }
+
     return FloodingRouter::send(p);
 }
 
@@ -53,6 +62,15 @@ bool ReliableRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
         }
     }
 
+    /* At this point we have already deleted the pending retransmission if this packet was an (implicit) ACK to it.
+       Now for all other pending retransmissions, we have to add the airtime of this received packet to the retransmission timer,
+       because while receiving this packet, we could not have received an (implicit) ACK for it.
+       If we don't add this, we will likely retransmit too early.
+    */
+    for (auto i = pending.begin(); i != pending.end(); i++) {
+        i->second.nextTxMsec += iface->getPacketTime(p);
+    }
+
     /* Resend implicit ACKs for repeated packets (assuming the original packet was sent with HOP_RELIABLE)
      * this way if an implicit ACK is dropped and a packet is resent we'll rebroadcast again.
      * Resending real ACKs is omitted, as you might receive a packet multiple times due to flooding and
@@ -148,7 +166,11 @@ bool ReliableRouter::stopRetransmission(GlobalPacketId key)
     if (old) {
         auto numErased = pending.erase(key);
         assert(numErased == 1);
+        // remove the 'original' (identified by originator and packet->id) from the txqueue and free it
         cancelSending(getFrom(old->packet), old->packet->id);
+        // now free the pooled copy for retransmission too. tryfix for #2228
+        if (old->packet)
+            packetPool.release(old->packet);
         return true;
     } else
         return false;

src/mesh/SX126xInterface.cpp

@@ -232,7 +232,7 @@ template <typename T> bool SX126xInterface<T>::isChannelActive()
 
     setStandby();
     result = lora.scanChannel();
-    if (result == RADIOLIB_PREAMBLE_DETECTED)
+    if (result == RADIOLIB_LORA_DETECTED)
         return true;
 
     assert(result != RADIOLIB_ERR_WRONG_MODEM);

src/mesh/SX128xInterface.cpp

@@ -222,7 +222,7 @@ template <typename T> bool SX128xInterface<T>::isChannelActive()
 
     setStandby();
     result = lora.scanChannel();
-    if (result == RADIOLIB_PREAMBLE_DETECTED)
+    if (result == RADIOLIB_LORA_DETECTED)
         return true;
 
     assert(result != RADIOLIB_ERR_WRONG_MODEM);

src/mesh/eth/ethClient.cpp

@@ -2,6 +2,7 @@
 #include "NodeDB.h"
 #include "RTC.h"
 #include "concurrency/Periodic.h"
+#include "main.h"
 #include "mesh/api/ethServerAPI.h"
 #include "mqtt/MQTT.h"
 #include "target_specific.h"
@@ -17,6 +18,9 @@ NTPClient timeClient(ntpUDP, config.network.ntp_server);
 uint32_t ntp_renew = 0;
 #endif
 
+EthernetUDP syslogClient;
+Syslog syslog(syslogClient);
+
 bool ethStartupComplete = 0;
 
 using namespace concurrency;
@@ -36,6 +40,27 @@ static int32_t reconnectETH()
             timeClient.begin();
             timeClient.setUpdateInterval(60 * 60); // Update once an hour
 #endif
+
+            if (config.network.rsyslog_server[0]) {
+                LOG_INFO("Starting Syslog client\n");
+                // Defaults
+                int serverPort = 514;
+                const char *serverAddr = config.network.rsyslog_server;
+                String server = String(serverAddr);
+                int delimIndex = server.indexOf(':');
+                if (delimIndex > 0) {
+                    String port = server.substring(delimIndex + 1, server.length());
+                    server[delimIndex] = 0;
+                    serverPort = port.toInt();
+                    serverAddr = server.c_str();
+                }
+                syslog.server(serverAddr, serverPort);
+                syslog.deviceHostname(getDeviceName());
+                syslog.appName("Meshtastic");
+                syslog.defaultPriority(LOGLEVEL_USER);
+                syslog.enable();
+            }
+
             // initWebServer();
             initApiServer();
 
@@ -143,10 +168,13 @@ bool isEthernetAvailable()
 {
 
     if (!config.network.eth_enabled) {
+        syslog.disable();
         return false;
     } else if (Ethernet.hardwareStatus() == EthernetNoHardware) {
+        syslog.disable();
         return false;
     } else if (Ethernet.linkStatus() == LinkOFF) {
+        syslog.disable();
         return false;
     } else {
         return true;

src/mesh/generated/meshtastic/admin.pb.c

@@ -9,6 +9,9 @@
 PB_BIND(meshtastic_AdminMessage, meshtastic_AdminMessage, 2)
 
 
+PB_BIND(meshtastic_HamParameters, meshtastic_HamParameters, AUTO)
+
+
 
 
 

src/mesh/generated/meshtastic/admin.pb.h

@@ -6,9 +6,9 @@
 #include <pb.h>
 #include "meshtastic/channel.pb.h"
 #include "meshtastic/config.pb.h"
-#include "meshtastic/device_metadata.pb.h"
 #include "meshtastic/mesh.pb.h"
 #include "meshtastic/module_config.pb.h"
+#include "meshtastic/connection_status.pb.h"
 
 #if PB_PROTO_HEADER_VERSION != 40
 #error Regenerate this file with the current version of nanopb generator.
@@ -56,6 +56,20 @@ typedef enum _meshtastic_AdminMessage_ModuleConfigType {
 } meshtastic_AdminMessage_ModuleConfigType;
 
 /* Struct definitions */
+/* Parameters for setting up Meshtastic for ameteur radio usage */
+typedef struct _meshtastic_HamParameters {
+    /* Amateur radio call sign, eg. KD2ABC */
+    char call_sign[8];
+    /* Transmit power in dBm at the LoRA transceiver, not including any amplification */
+    int32_t tx_power;
+    /* The selected frequency of LoRA operation
+ Please respect your local laws, regulations, and band plans.
+ Ensure your radio is capable of operating of the selected frequency before setting this. */
+    float frequency;
+    /* Optional short name of user */
+    char short_name[6];
+} meshtastic_HamParameters;
+
 /* This message is handled by the Admin module and is responsible for all settings/channel read/write operations.
  This message is used to do settings operations to both remote AND local nodes.
  (Prior to 1.2 these operations were done via special ToRadio operations) */
@@ -91,6 +105,12 @@ typedef struct _meshtastic_AdminMessage {
         bool get_ringtone_request;
         /* Get the Ringtone in the response to this message. */
         char get_ringtone_response[231];
+        /* Request the node to send it's connection status */
+        bool get_device_connection_status_request;
+        /* Device connection status response */
+        meshtastic_DeviceConnectionStatus get_device_connection_status_response;
+        /* Setup a node for licensed amateur (ham) radio operation */
+        meshtastic_HamParameters set_ham_mode;
         /* Set the owner for this node */
         meshtastic_User set_owner;
         /* Set channels (using the new API).
@@ -147,11 +167,18 @@ extern "C" {
 #define meshtastic_AdminMessage_payload_variant_get_module_config_request_ENUMTYPE meshtastic_AdminMessage_ModuleConfigType
 
 
+
 /* Initializer values for message structs */
 #define meshtastic_AdminMessage_init_default     {0, {0}}
+#define meshtastic_HamParameters_init_default    {"", 0, 0, ""}
 #define meshtastic_AdminMessage_init_zero        {0, {0}}
+#define meshtastic_HamParameters_init_zero       {"", 0, 0, ""}
 
 /* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_HamParameters_call_sign_tag   1
+#define meshtastic_HamParameters_tx_power_tag    2
+#define meshtastic_HamParameters_frequency_tag   3
+#define meshtastic_HamParameters_short_name_tag  4
 #define meshtastic_AdminMessage_get_channel_request_tag 1
 #define meshtastic_AdminMessage_get_channel_response_tag 2
 #define meshtastic_AdminMessage_get_owner_request_tag 3
@@ -166,6 +193,9 @@ extern "C" {
 #define meshtastic_AdminMessage_get_device_metadata_response_tag 13
 #define meshtastic_AdminMessage_get_ringtone_request_tag 14
 #define meshtastic_AdminMessage_get_ringtone_response_tag 15
+#define meshtastic_AdminMessage_get_device_connection_status_request_tag 16
+#define meshtastic_AdminMessage_get_device_connection_status_response_tag 17
+#define meshtastic_AdminMessage_set_ham_mode_tag 18
 #define meshtastic_AdminMessage_set_owner_tag    32
 #define meshtastic_AdminMessage_set_channel_tag  33
 #define meshtastic_AdminMessage_set_config_tag   34
@@ -197,6 +227,9 @@ X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,get_device_metadata_request,
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,get_device_metadata_response,get_device_metadata_response),  13) \
 X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,get_ringtone_request,get_ringtone_request),  14) \
 X(a, STATIC,   ONEOF,    STRING,   (payload_variant,get_ringtone_response,get_ringtone_response),  15) \
+X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,get_device_connection_status_request,get_device_connection_status_request),  16) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,get_device_connection_status_response,get_device_connection_status_response),  17) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,set_ham_mode,set_ham_mode),  18) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,set_owner,set_owner),  32) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,set_channel,set_channel),  33) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,set_config,set_config),  34) \
@@ -218,18 +251,31 @@ X(a, STATIC,   ONEOF,    INT32,    (payload_variant,nodedb_reset,nodedb_reset),
 #define meshtastic_AdminMessage_payload_variant_get_config_response_MSGTYPE meshtastic_Config
 #define meshtastic_AdminMessage_payload_variant_get_module_config_response_MSGTYPE meshtastic_ModuleConfig
 #define meshtastic_AdminMessage_payload_variant_get_device_metadata_response_MSGTYPE meshtastic_DeviceMetadata
+#define meshtastic_AdminMessage_payload_variant_get_device_connection_status_response_MSGTYPE meshtastic_DeviceConnectionStatus
+#define meshtastic_AdminMessage_payload_variant_set_ham_mode_MSGTYPE meshtastic_HamParameters
 #define meshtastic_AdminMessage_payload_variant_set_owner_MSGTYPE meshtastic_User
 #define meshtastic_AdminMessage_payload_variant_set_channel_MSGTYPE meshtastic_Channel
 #define meshtastic_AdminMessage_payload_variant_set_config_MSGTYPE meshtastic_Config
 #define meshtastic_AdminMessage_payload_variant_set_module_config_MSGTYPE meshtastic_ModuleConfig
 
+#define meshtastic_HamParameters_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, STRING,   call_sign,         1) \
+X(a, STATIC,   SINGULAR, INT32,    tx_power,          2) \
+X(a, STATIC,   SINGULAR, FLOAT,    frequency,         3) \
+X(a, STATIC,   SINGULAR, STRING,   short_name,        4)
+#define meshtastic_HamParameters_CALLBACK NULL
+#define meshtastic_HamParameters_DEFAULT NULL
+
 extern const pb_msgdesc_t meshtastic_AdminMessage_msg;
+extern const pb_msgdesc_t meshtastic_HamParameters_msg;
 
 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
 #define meshtastic_AdminMessage_fields &meshtastic_AdminMessage_msg
+#define meshtastic_HamParameters_fields &meshtastic_HamParameters_msg
 
 /* Maximum encoded size of messages (where known) */
 #define meshtastic_AdminMessage_size             234
+#define meshtastic_HamParameters_size            32
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/meshtastic/apponly.pb.h

@@ -54,7 +54,7 @@ extern const pb_msgdesc_t meshtastic_ChannelSet_msg;
 #define meshtastic_ChannelSet_fields &meshtastic_ChannelSet_msg
 
 /* Maximum encoded size of messages (where known) */
-#define meshtastic_ChannelSet_size               586
+#define meshtastic_ChannelSet_size               591
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/meshtastic/config.pb.h

@@ -31,7 +31,10 @@ typedef enum _meshtastic_Config_DeviceConfig_Role {
     meshtastic_Config_DeviceConfig_Role_REPEATER = 4,
     /* Tracker device role
    Position Mesh packets will be prioritized higher and sent more frequently by default. */
-    meshtastic_Config_DeviceConfig_Role_TRACKER = 5
+    meshtastic_Config_DeviceConfig_Role_TRACKER = 5,
+    /* Sensor device role
+   Telemetry Mesh packets will be prioritized higher and sent more frequently by default. */
+    meshtastic_Config_DeviceConfig_Role_SENSOR = 6
 } meshtastic_Config_DeviceConfig_Role;
 
 /* Defines the device's behavior for how messages are rebroadcast */
@@ -225,6 +228,9 @@ typedef struct _meshtastic_Config_DeviceConfig {
     uint32_t buzzer_gpio;
     /* Sets the role of node */
     meshtastic_Config_DeviceConfig_RebroadcastMode rebroadcast_mode;
+    /* Send our nodeinfo this often
+ Defaults to 900 Seconds (15 minutes) */
+    uint32_t node_info_broadcast_secs;
 } meshtastic_Config_DeviceConfig;
 
 /* Position Config */
@@ -408,6 +414,12 @@ typedef struct _meshtastic_Config_LoRaConfig {
     bool override_duty_cycle;
     /* If true, sets RX boosted gain mode on SX126X based radios */
     bool sx126x_rx_boosted_gain;
+    /* This parameter is for advanced users and licensed HAM radio operators.
+ Ignore Channel Calculation and use this frequency instead. The frequency_offset
+ will still be applied. This will allow you to use out-of-band frequencies.
+ Please respect your local laws and regulations. If you are a HAM, make sure you
+ enable HAM mode and turn off encryption. */
+    float override_frequency;
     /* For testing it is useful sometimes to force a node to never listen to
  particular other nodes (simulating radio out of range). All nodenums listed
  in ignore_incoming will have packets they send droped on receive (by router.cpp) */
@@ -444,8 +456,8 @@ extern "C" {
 
 /* Helper constants for enums */
 #define _meshtastic_Config_DeviceConfig_Role_MIN meshtastic_Config_DeviceConfig_Role_CLIENT
-#define _meshtastic_Config_DeviceConfig_Role_MAX meshtastic_Config_DeviceConfig_Role_TRACKER
-#define _meshtastic_Config_DeviceConfig_Role_ARRAYSIZE ((meshtastic_Config_DeviceConfig_Role)(meshtastic_Config_DeviceConfig_Role_TRACKER+1))
+#define _meshtastic_Config_DeviceConfig_Role_MAX meshtastic_Config_DeviceConfig_Role_SENSOR
+#define _meshtastic_Config_DeviceConfig_Role_ARRAYSIZE ((meshtastic_Config_DeviceConfig_Role)(meshtastic_Config_DeviceConfig_Role_SENSOR+1))
 
 #define _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN meshtastic_Config_DeviceConfig_RebroadcastMode_ALL
 #define _meshtastic_Config_DeviceConfig_RebroadcastMode_MAX meshtastic_Config_DeviceConfig_RebroadcastMode_LOCAL_ONLY
@@ -509,22 +521,22 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define meshtastic_Config_init_default           {0, {meshtastic_Config_DeviceConfig_init_default}}
-#define meshtastic_Config_DeviceConfig_init_default {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN}
+#define meshtastic_Config_DeviceConfig_init_default {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN, 0}
 #define meshtastic_Config_PositionConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_PowerConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_default {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_default, ""}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_default {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_default {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0}
-#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}}
+#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}}
 #define meshtastic_Config_BluetoothConfig_init_default {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_init_zero              {0, {meshtastic_Config_DeviceConfig_init_zero}}
-#define meshtastic_Config_DeviceConfig_init_zero {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN}
+#define meshtastic_Config_DeviceConfig_init_zero {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN, 0}
 #define meshtastic_Config_PositionConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_PowerConfig_init_zero  {0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_zero {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_zero, ""}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_zero {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_zero {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0}
-#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}}
+#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}}
 #define meshtastic_Config_BluetoothConfig_init_zero {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 
 /* Field tags (for use in manual encoding/decoding) */
@@ -534,6 +546,7 @@ extern "C" {
 #define meshtastic_Config_DeviceConfig_button_gpio_tag 4
 #define meshtastic_Config_DeviceConfig_buzzer_gpio_tag 5
 #define meshtastic_Config_DeviceConfig_rebroadcast_mode_tag 6
+#define meshtastic_Config_DeviceConfig_node_info_broadcast_secs_tag 7
 #define meshtastic_Config_PositionConfig_position_broadcast_secs_tag 1
 #define meshtastic_Config_PositionConfig_position_broadcast_smart_enabled_tag 2
 #define meshtastic_Config_PositionConfig_fixed_position_tag 3
@@ -585,6 +598,7 @@ extern "C" {
 #define meshtastic_Config_LoRaConfig_channel_num_tag 11
 #define meshtastic_Config_LoRaConfig_override_duty_cycle_tag 12
 #define meshtastic_Config_LoRaConfig_sx126x_rx_boosted_gain_tag 13
+#define meshtastic_Config_LoRaConfig_override_frequency_tag 14
 #define meshtastic_Config_LoRaConfig_ignore_incoming_tag 103
 #define meshtastic_Config_BluetoothConfig_enabled_tag 1
 #define meshtastic_Config_BluetoothConfig_mode_tag 2
@@ -622,7 +636,8 @@ X(a, STATIC,   SINGULAR, BOOL,     serial_enabled,    2) \
 X(a, STATIC,   SINGULAR, BOOL,     debug_log_enabled,   3) \
 X(a, STATIC,   SINGULAR, UINT32,   button_gpio,       4) \
 X(a, STATIC,   SINGULAR, UINT32,   buzzer_gpio,       5) \
-X(a, STATIC,   SINGULAR, UENUM,    rebroadcast_mode,   6)
+X(a, STATIC,   SINGULAR, UENUM,    rebroadcast_mode,   6) \
+X(a, STATIC,   SINGULAR, UINT32,   node_info_broadcast_secs,   7)
 #define meshtastic_Config_DeviceConfig_CALLBACK NULL
 #define meshtastic_Config_DeviceConfig_DEFAULT NULL
 
@@ -699,6 +714,7 @@ X(a, STATIC,   SINGULAR, INT32,    tx_power,         10) \
 X(a, STATIC,   SINGULAR, UINT32,   channel_num,      11) \
 X(a, STATIC,   SINGULAR, BOOL,     override_duty_cycle,  12) \
 X(a, STATIC,   SINGULAR, BOOL,     sx126x_rx_boosted_gain,  13) \
+X(a, STATIC,   SINGULAR, FLOAT,    override_frequency,  14) \
 X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103)
 #define meshtastic_Config_LoRaConfig_CALLBACK NULL
 #define meshtastic_Config_LoRaConfig_DEFAULT NULL
@@ -733,9 +749,9 @@ extern const pb_msgdesc_t meshtastic_Config_BluetoothConfig_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define meshtastic_Config_BluetoothConfig_size   10
-#define meshtastic_Config_DeviceConfig_size      20
+#define meshtastic_Config_DeviceConfig_size      26
 #define meshtastic_Config_DisplayConfig_size     26
-#define meshtastic_Config_LoRaConfig_size        72
+#define meshtastic_Config_LoRaConfig_size        77
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     195
 #define meshtastic_Config_PositionConfig_size    42

src/mesh/generated/meshtastic/connection_status.pb.c

@@ -0,0 +1,27 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.7 */
+
+#include "meshtastic/connection_status.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_DeviceConnectionStatus, meshtastic_DeviceConnectionStatus, AUTO)
+
+
+PB_BIND(meshtastic_WifiConnectionStatus, meshtastic_WifiConnectionStatus, AUTO)
+
+
+PB_BIND(meshtastic_EthernetConnectionStatus, meshtastic_EthernetConnectionStatus, AUTO)
+
+
+PB_BIND(meshtastic_NetworkConnectionStatus, meshtastic_NetworkConnectionStatus, AUTO)
+
+
+PB_BIND(meshtastic_BluetoothConnectionStatus, meshtastic_BluetoothConnectionStatus, AUTO)
+
+
+PB_BIND(meshtastic_SerialConnectionStatus, meshtastic_SerialConnectionStatus, AUTO)
+
+
+

src/mesh/generated/meshtastic/connection_status.pb.h

@@ -0,0 +1,189 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.7 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_CONNECTION_STATUS_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_CONNECTION_STATUS_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+/* Ethernet or WiFi connection status */
+typedef struct _meshtastic_NetworkConnectionStatus {
+    /* IP address of device */
+    uint32_t ip_address;
+    /* Whether the device has an active connection or not */
+    bool is_connected;
+    /* Whether the device has an active connection to an MQTT broker or not */
+    bool is_mqtt_connected;
+    /* Whether the device is actively remote syslogging or not */
+    bool is_syslog_connected;
+} meshtastic_NetworkConnectionStatus;
+
+/* WiFi connection status */
+typedef struct _meshtastic_WifiConnectionStatus {
+    /* Connection status */
+    bool has_status;
+    meshtastic_NetworkConnectionStatus status;
+    /* WiFi access point ssid */
+    char ssid[33];
+    /* Rssi of wireless connection */
+    int32_t rssi;
+} meshtastic_WifiConnectionStatus;
+
+/* Ethernet connection status */
+typedef struct _meshtastic_EthernetConnectionStatus {
+    /* Connection status */
+    bool has_status;
+    meshtastic_NetworkConnectionStatus status;
+} meshtastic_EthernetConnectionStatus;
+
+/* Bluetooth connection status */
+typedef struct _meshtastic_BluetoothConnectionStatus {
+    /* The pairing pin for bluetooth */
+    uint32_t pin;
+    /* Rssi of bluetooth connection */
+    int32_t rssi;
+    /* Whether the device has an active connection or not */
+    bool is_connected;
+} meshtastic_BluetoothConnectionStatus;
+
+/* Serial connection status */
+typedef struct _meshtastic_SerialConnectionStatus {
+    /* The serial baud rate */
+    uint32_t baud;
+    /* Whether the device has an active connection or not */
+    bool is_connected;
+} meshtastic_SerialConnectionStatus;
+
+typedef struct _meshtastic_DeviceConnectionStatus {
+    /* WiFi Status */
+    bool has_wifi;
+    meshtastic_WifiConnectionStatus wifi;
+    /* WiFi Status */
+    bool has_ethernet;
+    meshtastic_EthernetConnectionStatus ethernet;
+    /* Bluetooth Status */
+    bool has_bluetooth;
+    meshtastic_BluetoothConnectionStatus bluetooth;
+    /* Serial Status */
+    bool has_serial;
+    meshtastic_SerialConnectionStatus serial;
+} meshtastic_DeviceConnectionStatus;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define meshtastic_DeviceConnectionStatus_init_default {false, meshtastic_WifiConnectionStatus_init_default, false, meshtastic_EthernetConnectionStatus_init_default, false, meshtastic_BluetoothConnectionStatus_init_default, false, meshtastic_SerialConnectionStatus_init_default}
+#define meshtastic_WifiConnectionStatus_init_default {false, meshtastic_NetworkConnectionStatus_init_default, "", 0}
+#define meshtastic_EthernetConnectionStatus_init_default {false, meshtastic_NetworkConnectionStatus_init_default}
+#define meshtastic_NetworkConnectionStatus_init_default {0, 0, 0, 0}
+#define meshtastic_BluetoothConnectionStatus_init_default {0, 0, 0}
+#define meshtastic_SerialConnectionStatus_init_default {0, 0}
+#define meshtastic_DeviceConnectionStatus_init_zero {false, meshtastic_WifiConnectionStatus_init_zero, false, meshtastic_EthernetConnectionStatus_init_zero, false, meshtastic_BluetoothConnectionStatus_init_zero, false, meshtastic_SerialConnectionStatus_init_zero}
+#define meshtastic_WifiConnectionStatus_init_zero {false, meshtastic_NetworkConnectionStatus_init_zero, "", 0}
+#define meshtastic_EthernetConnectionStatus_init_zero {false, meshtastic_NetworkConnectionStatus_init_zero}
+#define meshtastic_NetworkConnectionStatus_init_zero {0, 0, 0, 0}
+#define meshtastic_BluetoothConnectionStatus_init_zero {0, 0, 0}
+#define meshtastic_SerialConnectionStatus_init_zero {0, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_NetworkConnectionStatus_ip_address_tag 1
+#define meshtastic_NetworkConnectionStatus_is_connected_tag 2
+#define meshtastic_NetworkConnectionStatus_is_mqtt_connected_tag 3
+#define meshtastic_NetworkConnectionStatus_is_syslog_connected_tag 4
+#define meshtastic_WifiConnectionStatus_status_tag 1
+#define meshtastic_WifiConnectionStatus_ssid_tag 2
+#define meshtastic_WifiConnectionStatus_rssi_tag 3
+#define meshtastic_EthernetConnectionStatus_status_tag 1
+#define meshtastic_BluetoothConnectionStatus_pin_tag 1
+#define meshtastic_BluetoothConnectionStatus_rssi_tag 2
+#define meshtastic_BluetoothConnectionStatus_is_connected_tag 3
+#define meshtastic_SerialConnectionStatus_baud_tag 1
+#define meshtastic_SerialConnectionStatus_is_connected_tag 2
+#define meshtastic_DeviceConnectionStatus_wifi_tag 1
+#define meshtastic_DeviceConnectionStatus_ethernet_tag 2
+#define meshtastic_DeviceConnectionStatus_bluetooth_tag 3
+#define meshtastic_DeviceConnectionStatus_serial_tag 4
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_DeviceConnectionStatus_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  wifi,              1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  ethernet,          2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  bluetooth,         3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  serial,            4)
+#define meshtastic_DeviceConnectionStatus_CALLBACK NULL
+#define meshtastic_DeviceConnectionStatus_DEFAULT NULL
+#define meshtastic_DeviceConnectionStatus_wifi_MSGTYPE meshtastic_WifiConnectionStatus
+#define meshtastic_DeviceConnectionStatus_ethernet_MSGTYPE meshtastic_EthernetConnectionStatus
+#define meshtastic_DeviceConnectionStatus_bluetooth_MSGTYPE meshtastic_BluetoothConnectionStatus
+#define meshtastic_DeviceConnectionStatus_serial_MSGTYPE meshtastic_SerialConnectionStatus
+
+#define meshtastic_WifiConnectionStatus_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  status,            1) \
+X(a, STATIC,   SINGULAR, STRING,   ssid,              2) \
+X(a, STATIC,   SINGULAR, INT32,    rssi,              3)
+#define meshtastic_WifiConnectionStatus_CALLBACK NULL
+#define meshtastic_WifiConnectionStatus_DEFAULT NULL
+#define meshtastic_WifiConnectionStatus_status_MSGTYPE meshtastic_NetworkConnectionStatus
+
+#define meshtastic_EthernetConnectionStatus_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  status,            1)
+#define meshtastic_EthernetConnectionStatus_CALLBACK NULL
+#define meshtastic_EthernetConnectionStatus_DEFAULT NULL
+#define meshtastic_EthernetConnectionStatus_status_MSGTYPE meshtastic_NetworkConnectionStatus
+
+#define meshtastic_NetworkConnectionStatus_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, FIXED32,  ip_address,        1) \
+X(a, STATIC,   SINGULAR, BOOL,     is_connected,      2) \
+X(a, STATIC,   SINGULAR, BOOL,     is_mqtt_connected,   3) \
+X(a, STATIC,   SINGULAR, BOOL,     is_syslog_connected,   4)
+#define meshtastic_NetworkConnectionStatus_CALLBACK NULL
+#define meshtastic_NetworkConnectionStatus_DEFAULT NULL
+
+#define meshtastic_BluetoothConnectionStatus_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   pin,               1) \
+X(a, STATIC,   SINGULAR, INT32,    rssi,              2) \
+X(a, STATIC,   SINGULAR, BOOL,     is_connected,      3)
+#define meshtastic_BluetoothConnectionStatus_CALLBACK NULL
+#define meshtastic_BluetoothConnectionStatus_DEFAULT NULL
+
+#define meshtastic_SerialConnectionStatus_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   baud,              1) \
+X(a, STATIC,   SINGULAR, BOOL,     is_connected,      2)
+#define meshtastic_SerialConnectionStatus_CALLBACK NULL
+#define meshtastic_SerialConnectionStatus_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_DeviceConnectionStatus_msg;
+extern const pb_msgdesc_t meshtastic_WifiConnectionStatus_msg;
+extern const pb_msgdesc_t meshtastic_EthernetConnectionStatus_msg;
+extern const pb_msgdesc_t meshtastic_NetworkConnectionStatus_msg;
+extern const pb_msgdesc_t meshtastic_BluetoothConnectionStatus_msg;
+extern const pb_msgdesc_t meshtastic_SerialConnectionStatus_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_DeviceConnectionStatus_fields &meshtastic_DeviceConnectionStatus_msg
+#define meshtastic_WifiConnectionStatus_fields &meshtastic_WifiConnectionStatus_msg
+#define meshtastic_EthernetConnectionStatus_fields &meshtastic_EthernetConnectionStatus_msg
+#define meshtastic_NetworkConnectionStatus_fields &meshtastic_NetworkConnectionStatus_msg
+#define meshtastic_BluetoothConnectionStatus_fields &meshtastic_BluetoothConnectionStatus_msg
+#define meshtastic_SerialConnectionStatus_fields &meshtastic_SerialConnectionStatus_msg
+
+/* Maximum encoded size of messages (where known) */
+#define meshtastic_BluetoothConnectionStatus_size 19
+#define meshtastic_DeviceConnectionStatus_size   106
+#define meshtastic_EthernetConnectionStatus_size 13
+#define meshtastic_NetworkConnectionStatus_size  11
+#define meshtastic_SerialConnectionStatus_size   8
+#define meshtastic_WifiConnectionStatus_size     58
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/device_metadata.pb.c

@@ -1,12 +0,0 @@
-/* Automatically generated nanopb constant definitions */
-/* Generated by nanopb-0.4.7 */
-
-#include "meshtastic/device_metadata.pb.h"
-#if PB_PROTO_HEADER_VERSION != 40
-#error Regenerate this file with the current version of nanopb generator.
-#endif
-
-PB_BIND(meshtastic_DeviceMetadata, meshtastic_DeviceMetadata, AUTO)
-
-
-

src/mesh/generated/meshtastic/device_metadata.pb.h

@@ -1,78 +0,0 @@
-/* Automatically generated nanopb header */
-/* Generated by nanopb-0.4.7 */
-
-#ifndef PB_MESHTASTIC_MESHTASTIC_DEVICE_METADATA_PB_H_INCLUDED
-#define PB_MESHTASTIC_MESHTASTIC_DEVICE_METADATA_PB_H_INCLUDED
-#include <pb.h>
-#include "meshtastic/config.pb.h"
-
-#if PB_PROTO_HEADER_VERSION != 40
-#error Regenerate this file with the current version of nanopb generator.
-#endif
-
-/* Struct definitions */
-/* Device metadata response */
-typedef struct _meshtastic_DeviceMetadata {
-    /* Device firmware version string */
-    char firmware_version[18];
-    /* Device state version */
-    uint32_t device_state_version;
-    /* Indicates whether the device can shutdown CPU natively or via power management chip */
-    bool canShutdown;
-    /* Indicates that the device has native wifi capability */
-    bool hasWifi;
-    /* Indicates that the device has native bluetooth capability */
-    bool hasBluetooth;
-    /* Indicates that the device has an ethernet peripheral */
-    bool hasEthernet;
-    /* Indicates that the device's role in the mesh */
-    meshtastic_Config_DeviceConfig_Role role;
-    /* Indicates the device's current enabled position flags */
-    uint32_t position_flags;
-} meshtastic_DeviceMetadata;
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Initializer values for message structs */
-#define meshtastic_DeviceMetadata_init_default   {"", 0, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_Role_MIN, 0}
-#define meshtastic_DeviceMetadata_init_zero      {"", 0, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_Role_MIN, 0}
-
-/* Field tags (for use in manual encoding/decoding) */
-#define meshtastic_DeviceMetadata_firmware_version_tag 1
-#define meshtastic_DeviceMetadata_device_state_version_tag 2
-#define meshtastic_DeviceMetadata_canShutdown_tag 3
-#define meshtastic_DeviceMetadata_hasWifi_tag    4
-#define meshtastic_DeviceMetadata_hasBluetooth_tag 5
-#define meshtastic_DeviceMetadata_hasEthernet_tag 6
-#define meshtastic_DeviceMetadata_role_tag       7
-#define meshtastic_DeviceMetadata_position_flags_tag 8
-
-/* Struct field encoding specification for nanopb */
-#define meshtastic_DeviceMetadata_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, STRING,   firmware_version,   1) \
-X(a, STATIC,   SINGULAR, UINT32,   device_state_version,   2) \
-X(a, STATIC,   SINGULAR, BOOL,     canShutdown,       3) \
-X(a, STATIC,   SINGULAR, BOOL,     hasWifi,           4) \
-X(a, STATIC,   SINGULAR, BOOL,     hasBluetooth,      5) \
-X(a, STATIC,   SINGULAR, BOOL,     hasEthernet,       6) \
-X(a, STATIC,   SINGULAR, UENUM,    role,              7) \
-X(a, STATIC,   SINGULAR, UINT32,   position_flags,    8)
-#define meshtastic_DeviceMetadata_CALLBACK NULL
-#define meshtastic_DeviceMetadata_DEFAULT NULL
-
-extern const pb_msgdesc_t meshtastic_DeviceMetadata_msg;
-
-/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
-#define meshtastic_DeviceMetadata_fields &meshtastic_DeviceMetadata_msg
-
-/* Maximum encoded size of messages (where known) */
-#define meshtastic_DeviceMetadata_size           41
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif

src/mesh/generated/meshtastic/deviceonly.pb.h

@@ -5,6 +5,7 @@
 #define PB_MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_INCLUDED
 #include <pb.h>
 #include "meshtastic/channel.pb.h"
+#include "meshtastic/localonly.pb.h"
 #include "meshtastic/mesh.pb.h"
 
 #if PB_PROTO_HEADER_VERSION != 40
@@ -85,6 +86,12 @@ typedef struct _meshtastic_OEMStore {
     char oem_text[40];
     /* The default device encryption key, 16 or 32 byte */
     meshtastic_OEMStore_oem_aes_key_t oem_aes_key;
+    /* A Preset LocalConfig to apply during factory reset */
+    bool has_oem_local_config;
+    meshtastic_LocalConfig oem_local_config;
+    /* A Preset LocalModuleConfig to apply during factory reset */
+    bool has_oem_local_module_config;
+    meshtastic_LocalModuleConfig oem_local_module_config;
 } meshtastic_OEMStore;
 
 
@@ -105,10 +112,10 @@ extern "C" {
 /* Initializer values for message structs */
 #define meshtastic_DeviceState_init_default      {false, meshtastic_MyNodeInfo_init_default, false, meshtastic_User_init_default, 0, {meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default, meshtastic_NodeInfo_init_default}, 0, {meshtastic_MeshPacket_init_default}, false, meshtastic_MeshPacket_init_default, 0, 0, 0}
 #define meshtastic_ChannelFile_init_default      {0, {meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default}, 0}
-#define meshtastic_OEMStore_init_default         {0, 0, {0, {0}}, _meshtastic_ScreenFonts_MIN, "", {0, {0}}}
+#define meshtastic_OEMStore_init_default         {0, 0, {0, {0}}, _meshtastic_ScreenFonts_MIN, "", {0, {0}}, false, meshtastic_LocalConfig_init_default, false, meshtastic_LocalModuleConfig_init_default}
 #define meshtastic_DeviceState_init_zero         {false, meshtastic_MyNodeInfo_init_zero, false, meshtastic_User_init_zero, 0, {meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero, meshtastic_NodeInfo_init_zero}, 0, {meshtastic_MeshPacket_init_zero}, false, meshtastic_MeshPacket_init_zero, 0, 0, 0}
 #define meshtastic_ChannelFile_init_zero         {0, {meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero}, 0}
-#define meshtastic_OEMStore_init_zero            {0, 0, {0, {0}}, _meshtastic_ScreenFonts_MIN, "", {0, {0}}}
+#define meshtastic_OEMStore_init_zero            {0, 0, {0, {0}}, _meshtastic_ScreenFonts_MIN, "", {0, {0}}, false, meshtastic_LocalConfig_init_zero, false, meshtastic_LocalModuleConfig_init_zero}
 
 /* Field tags (for use in manual encoding/decoding) */
 #define meshtastic_DeviceState_my_node_tag       2
@@ -127,6 +134,8 @@ extern "C" {
 #define meshtastic_OEMStore_oem_font_tag         4
 #define meshtastic_OEMStore_oem_text_tag         5
 #define meshtastic_OEMStore_oem_aes_key_tag      6
+#define meshtastic_OEMStore_oem_local_config_tag 7
+#define meshtastic_OEMStore_oem_local_module_config_tag 8
 
 /* Struct field encoding specification for nanopb */
 #define meshtastic_DeviceState_FIELDLIST(X, a) \
@@ -159,9 +168,13 @@ X(a, STATIC,   SINGULAR, UINT32,   oem_icon_height,   2) \
 X(a, STATIC,   SINGULAR, BYTES,    oem_icon_bits,     3) \
 X(a, STATIC,   SINGULAR, UENUM,    oem_font,          4) \
 X(a, STATIC,   SINGULAR, STRING,   oem_text,          5) \
-X(a, STATIC,   SINGULAR, BYTES,    oem_aes_key,       6)
+X(a, STATIC,   SINGULAR, BYTES,    oem_aes_key,       6) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  oem_local_config,   7) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  oem_local_module_config,   8)
 #define meshtastic_OEMStore_CALLBACK NULL
 #define meshtastic_OEMStore_DEFAULT NULL
+#define meshtastic_OEMStore_oem_local_config_MSGTYPE meshtastic_LocalConfig
+#define meshtastic_OEMStore_oem_local_module_config_MSGTYPE meshtastic_LocalModuleConfig
 
 extern const pb_msgdesc_t meshtastic_DeviceState_msg;
 extern const pb_msgdesc_t meshtastic_ChannelFile_msg;
@@ -175,7 +188,7 @@ extern const pb_msgdesc_t meshtastic_OEMStore_msg;
 /* Maximum encoded size of messages (where known) */
 #define meshtastic_ChannelFile_size              638
 #define meshtastic_DeviceState_size              21800
-#define meshtastic_OEMStore_size                 2140
+#define meshtastic_OEMStore_size                 3006
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/meshtastic/localonly.pb.h

@@ -156,8 +156,8 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;
 #define meshtastic_LocalModuleConfig_fields &meshtastic_LocalModuleConfig_msg
 
 /* Maximum encoded size of messages (where known) */
-#define meshtastic_LocalConfig_size              429
-#define meshtastic_LocalModuleConfig_size        412
+#define meshtastic_LocalConfig_size              440
+#define meshtastic_LocalModuleConfig_size        420
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/meshtastic/mesh.pb.c

@@ -48,6 +48,9 @@ PB_BIND(meshtastic_ToRadio, meshtastic_ToRadio, 2)
 PB_BIND(meshtastic_Compressed, meshtastic_Compressed, AUTO)
 
 
+PB_BIND(meshtastic_DeviceMetadata, meshtastic_DeviceMetadata, AUTO)
+
+
 
 
 

src/mesh/generated/meshtastic/mesh.pb.h

@@ -57,9 +57,13 @@ typedef enum _meshtastic_HardwareModel {
     meshtastic_HardwareModel_TLORA_V2_1_1P8 = 15,
     /* TODO: REPLACE */
     meshtastic_HardwareModel_TLORA_T3_S3 = 16,
+    /* B&Q Consulting Nano G1 Explorer: https://wiki.uniteng.com/en/meshtastic/nano-g1-explorer */
+    meshtastic_HardwareModel_NANO_G1_EXPLORER = 17,
     /* B&Q Consulting Station Edition G1: https://uniteng.com/wiki/doku.php?id=meshtastic:station */
     meshtastic_HardwareModel_STATION_G1 = 25,
-    /* Less common/prototype boards listed here (needs one more byte over the air) */
+    /* ---------------------------------------------------------------------------
+ Less common/prototype boards listed here (needs one more byte over the air)
+ --------------------------------------------------------------------------- */
     meshtastic_HardwareModel_LORA_RELAY_V1 = 32,
     /* TODO: REPLACE */
     meshtastic_HardwareModel_NRF52840DK = 33,
@@ -87,7 +91,11 @@ typedef enum _meshtastic_HardwareModel {
     meshtastic_HardwareModel_HELTEC_WSL_V3 = 44,
     /* New BETAFPV ELRS Micro TX Module 2.4G with ESP32 CPU */
     meshtastic_HardwareModel_BETAFPV_2400_TX = 45,
-    /* Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits. */
+    /* BetaFPV ExpressLRS "Nano" TX Module 900MHz with ESP32 CPU */
+    meshtastic_HardwareModel_BETAFPV_900_NANO_TX = 46,
+    /* ------------------------------------------------------------------------------------------------------------------------------------------
+ Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
+ ------------------------------------------------------------------------------------------------------------------------------------------ */
     meshtastic_HardwareModel_PRIVATE_HW = 255
 } meshtastic_HardwareModel;
 
@@ -637,6 +645,61 @@ typedef struct _meshtastic_QueueStatus {
     uint32_t mesh_packet_id;
 } meshtastic_QueueStatus;
 
+/* Packets/commands to the radio will be written (reliably) to the toRadio characteristic.
+ Once the write completes the phone can assume it is handled. */
+typedef struct _meshtastic_ToRadio {
+    pb_size_t which_payload_variant;
+    union {
+        /* Send this packet on the mesh */
+        meshtastic_MeshPacket packet;
+        /* Phone wants radio to send full node db to the phone, This is
+     typically the first packet sent to the radio when the phone gets a
+     bluetooth connection. The radio will respond by sending back a
+     MyNodeInfo, a owner, a radio config and a series of
+     FromRadio.node_infos, and config_complete
+     the integer you write into this field will be reported back in the
+     config_complete_id response this allows clients to never be confused by
+     a stale old partially sent config. */
+        uint32_t want_config_id;
+        /* Tell API server we are disconnecting now.
+     This is useful for serial links where there is no hardware/protocol based notification that the client has dropped the link.
+     (Sending this message is optional for clients) */
+        bool disconnect;
+        meshtastic_XModem xmodemPacket;
+    };
+} meshtastic_ToRadio;
+
+typedef PB_BYTES_ARRAY_T(237) meshtastic_Compressed_data_t;
+/* Compressed message payload */
+typedef struct _meshtastic_Compressed {
+    /* PortNum to determine the how to handle the compressed payload. */
+    meshtastic_PortNum portnum;
+    /* Compressed data. */
+    meshtastic_Compressed_data_t data;
+} meshtastic_Compressed;
+
+/* Device metadata response */
+typedef struct _meshtastic_DeviceMetadata {
+    /* Device firmware version string */
+    char firmware_version[18];
+    /* Device state version */
+    uint32_t device_state_version;
+    /* Indicates whether the device can shutdown CPU natively or via power management chip */
+    bool canShutdown;
+    /* Indicates that the device has native wifi capability */
+    bool hasWifi;
+    /* Indicates that the device has native bluetooth capability */
+    bool hasBluetooth;
+    /* Indicates that the device has an ethernet peripheral */
+    bool hasEthernet;
+    /* Indicates that the device's role in the mesh */
+    meshtastic_Config_DeviceConfig_Role role;
+    /* Indicates the device's current enabled position flags */
+    uint32_t position_flags;
+    /* Device hardware model */
+    meshtastic_HardwareModel hw_model;
+} meshtastic_DeviceMetadata;
+
 /* Packets from the radio to the phone will appear on the fromRadio characteristic.
  It will support READ and NOTIFY. When a new packet arrives the device will BLE notify?
  It will sit in that descriptor until consumed by the phone,
@@ -677,42 +740,11 @@ typedef struct _meshtastic_FromRadio {
         meshtastic_QueueStatus queueStatus;
         /* File Transfer Chunk */
         meshtastic_XModem xmodemPacket;
+        /* Device metadata message */
+        meshtastic_DeviceMetadata metadata;
     };
 } meshtastic_FromRadio;
 
-/* Packets/commands to the radio will be written (reliably) to the toRadio characteristic.
- Once the write completes the phone can assume it is handled. */
-typedef struct _meshtastic_ToRadio {
-    pb_size_t which_payload_variant;
-    union {
-        /* Send this packet on the mesh */
-        meshtastic_MeshPacket packet;
-        /* Phone wants radio to send full node db to the phone, This is
-     typically the first packet sent to the radio when the phone gets a
-     bluetooth connection. The radio will respond by sending back a
-     MyNodeInfo, a owner, a radio config and a series of
-     FromRadio.node_infos, and config_complete
-     the integer you write into this field will be reported back in the
-     config_complete_id response this allows clients to never be confused by
-     a stale old partially sent config. */
-        uint32_t want_config_id;
-        /* Tell API server we are disconnecting now.
-     This is useful for serial links where there is no hardware/protocol based notification that the client has dropped the link.
-     (Sending this message is optional for clients) */
-        bool disconnect;
-        meshtastic_XModem xmodemPacket;
-    };
-} meshtastic_ToRadio;
-
-typedef PB_BYTES_ARRAY_T(237) meshtastic_Compressed_data_t;
-/* Compressed message payload */
-typedef struct _meshtastic_Compressed {
-    /* PortNum to determine the how to handle the compressed payload. */
-    meshtastic_PortNum portnum;
-    /* Compressed data. */
-    meshtastic_Compressed_data_t data;
-} meshtastic_Compressed;
-
 
 #ifdef __cplusplus
 extern "C" {
@@ -779,6 +811,9 @@ extern "C" {
 
 #define meshtastic_Compressed_portnum_ENUMTYPE meshtastic_PortNum
 
+#define meshtastic_DeviceMetadata_role_ENUMTYPE meshtastic_Config_DeviceConfig_Role
+#define meshtastic_DeviceMetadata_hw_model_ENUMTYPE meshtastic_HardwareModel
+
 
 /* Initializer values for message structs */
 #define meshtastic_Position_init_default         {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN, _meshtastic_Position_AltSource_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
@@ -795,6 +830,7 @@ extern "C" {
 #define meshtastic_FromRadio_init_default        {0, 0, {meshtastic_MeshPacket_init_default}}
 #define meshtastic_ToRadio_init_default          {0, {meshtastic_MeshPacket_init_default}}
 #define meshtastic_Compressed_init_default       {_meshtastic_PortNum_MIN, {0, {0}}}
+#define meshtastic_DeviceMetadata_init_default   {"", 0, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_Role_MIN, 0, _meshtastic_HardwareModel_MIN}
 #define meshtastic_Position_init_zero            {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN, _meshtastic_Position_AltSource_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_User_init_zero                {"", "", "", {0}, _meshtastic_HardwareModel_MIN, 0}
 #define meshtastic_RouteDiscovery_init_zero      {0, {0, 0, 0, 0, 0, 0, 0, 0}}
@@ -809,6 +845,7 @@ extern "C" {
 #define meshtastic_FromRadio_init_zero           {0, 0, {meshtastic_MeshPacket_init_zero}}
 #define meshtastic_ToRadio_init_zero             {0, {meshtastic_MeshPacket_init_zero}}
 #define meshtastic_Compressed_init_zero          {_meshtastic_PortNum_MIN, {0, {0}}}
+#define meshtastic_DeviceMetadata_init_zero      {"", 0, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_Role_MIN, 0, _meshtastic_HardwareModel_MIN}
 
 /* Field tags (for use in manual encoding/decoding) */
 #define meshtastic_Position_latitude_i_tag       1
@@ -902,6 +939,21 @@ extern "C" {
 #define meshtastic_QueueStatus_free_tag          2
 #define meshtastic_QueueStatus_maxlen_tag        3
 #define meshtastic_QueueStatus_mesh_packet_id_tag 4
+#define meshtastic_ToRadio_packet_tag            1
+#define meshtastic_ToRadio_want_config_id_tag    3
+#define meshtastic_ToRadio_disconnect_tag        4
+#define meshtastic_ToRadio_xmodemPacket_tag      5
+#define meshtastic_Compressed_portnum_tag        1
+#define meshtastic_Compressed_data_tag           2
+#define meshtastic_DeviceMetadata_firmware_version_tag 1
+#define meshtastic_DeviceMetadata_device_state_version_tag 2
+#define meshtastic_DeviceMetadata_canShutdown_tag 3
+#define meshtastic_DeviceMetadata_hasWifi_tag    4
+#define meshtastic_DeviceMetadata_hasBluetooth_tag 5
+#define meshtastic_DeviceMetadata_hasEthernet_tag 6
+#define meshtastic_DeviceMetadata_role_tag       7
+#define meshtastic_DeviceMetadata_position_flags_tag 8
+#define meshtastic_DeviceMetadata_hw_model_tag   9
 #define meshtastic_FromRadio_id_tag              1
 #define meshtastic_FromRadio_packet_tag          2
 #define meshtastic_FromRadio_my_info_tag         3
@@ -914,12 +966,7 @@ extern "C" {
 #define meshtastic_FromRadio_channel_tag         10
 #define meshtastic_FromRadio_queueStatus_tag     11
 #define meshtastic_FromRadio_xmodemPacket_tag    12
-#define meshtastic_ToRadio_packet_tag            1
-#define meshtastic_ToRadio_want_config_id_tag    3
-#define meshtastic_ToRadio_disconnect_tag        4
-#define meshtastic_ToRadio_xmodemPacket_tag      5
-#define meshtastic_Compressed_portnum_tag        1
-#define meshtastic_Compressed_data_tag           2
+#define meshtastic_FromRadio_metadata_tag        13
 
 /* Struct field encoding specification for nanopb */
 #define meshtastic_Position_FIELDLIST(X, a) \
@@ -1075,7 +1122,8 @@ X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,rebooted,rebooted),   8) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,moduleConfig,moduleConfig),   9) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,channel,channel),  10) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,queueStatus,queueStatus),  11) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,xmodemPacket,xmodemPacket),  12)
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,xmodemPacket,xmodemPacket),  12) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,metadata,metadata),  13)
 #define meshtastic_FromRadio_CALLBACK NULL
 #define meshtastic_FromRadio_DEFAULT NULL
 #define meshtastic_FromRadio_payload_variant_packet_MSGTYPE meshtastic_MeshPacket
@@ -1087,6 +1135,7 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,xmodemPacket,xmodemPacket),
 #define meshtastic_FromRadio_payload_variant_channel_MSGTYPE meshtastic_Channel
 #define meshtastic_FromRadio_payload_variant_queueStatus_MSGTYPE meshtastic_QueueStatus
 #define meshtastic_FromRadio_payload_variant_xmodemPacket_MSGTYPE meshtastic_XModem
+#define meshtastic_FromRadio_payload_variant_metadata_MSGTYPE meshtastic_DeviceMetadata
 
 #define meshtastic_ToRadio_FIELDLIST(X, a) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,packet,packet),   1) \
@@ -1104,6 +1153,19 @@ X(a, STATIC,   SINGULAR, BYTES,    data,              2)
 #define meshtastic_Compressed_CALLBACK NULL
 #define meshtastic_Compressed_DEFAULT NULL
 
+#define meshtastic_DeviceMetadata_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, STRING,   firmware_version,   1) \
+X(a, STATIC,   SINGULAR, UINT32,   device_state_version,   2) \
+X(a, STATIC,   SINGULAR, BOOL,     canShutdown,       3) \
+X(a, STATIC,   SINGULAR, BOOL,     hasWifi,           4) \
+X(a, STATIC,   SINGULAR, BOOL,     hasBluetooth,      5) \
+X(a, STATIC,   SINGULAR, BOOL,     hasEthernet,       6) \
+X(a, STATIC,   SINGULAR, UENUM,    role,              7) \
+X(a, STATIC,   SINGULAR, UINT32,   position_flags,    8) \
+X(a, STATIC,   SINGULAR, UENUM,    hw_model,          9)
+#define meshtastic_DeviceMetadata_CALLBACK NULL
+#define meshtastic_DeviceMetadata_DEFAULT NULL
+
 extern const pb_msgdesc_t meshtastic_Position_msg;
 extern const pb_msgdesc_t meshtastic_User_msg;
 extern const pb_msgdesc_t meshtastic_RouteDiscovery_msg;
@@ -1118,6 +1180,7 @@ extern const pb_msgdesc_t meshtastic_QueueStatus_msg;
 extern const pb_msgdesc_t meshtastic_FromRadio_msg;
 extern const pb_msgdesc_t meshtastic_ToRadio_msg;
 extern const pb_msgdesc_t meshtastic_Compressed_msg;
+extern const pb_msgdesc_t meshtastic_DeviceMetadata_msg;
 
 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
 #define meshtastic_Position_fields &meshtastic_Position_msg
@@ -1134,10 +1197,12 @@ extern const pb_msgdesc_t meshtastic_Compressed_msg;
 #define meshtastic_FromRadio_fields &meshtastic_FromRadio_msg
 #define meshtastic_ToRadio_fields &meshtastic_ToRadio_msg
 #define meshtastic_Compressed_fields &meshtastic_Compressed_msg
+#define meshtastic_DeviceMetadata_fields &meshtastic_DeviceMetadata_msg
 
 /* Maximum encoded size of messages (where known) */
 #define meshtastic_Compressed_size               243
 #define meshtastic_Data_size                     270
+#define meshtastic_DeviceMetadata_size           44
 #define meshtastic_FromRadio_size                330
 #define meshtastic_LogRecord_size                81
 #define meshtastic_MeshPacket_size               321

src/mesh/generated/meshtastic/module_config.pb.h

@@ -222,6 +222,11 @@ typedef struct _meshtastic_ModuleConfig_TelemetryConfig {
     /* We'll always read the sensor in Celsius, but sometimes we might want to
  display the results in Fahrenheit as a "user preference". */
     bool environment_display_fahrenheit;
+    /* Enable/Disable the air quality metrics */
+    bool air_quality_enabled;
+    /* Interval in seconds of how often we should try to send our
+ air quality metrics to the mesh */
+    uint32_t air_quality_interval;
 } meshtastic_ModuleConfig_TelemetryConfig;
 
 /* TODO: REPLACE */
@@ -325,7 +330,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_StoreForwardConfig_init_default {0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_RangeTestConfig_init_default {0, 0, 0}
-#define meshtastic_ModuleConfig_TelemetryConfig_init_default {0, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_TelemetryConfig_init_default {0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_CannedMessageConfig_init_default {0, 0, 0, 0, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, 0, 0, "", 0}
 #define meshtastic_ModuleConfig_init_zero        {0, {meshtastic_ModuleConfig_MQTTConfig_init_zero}}
 #define meshtastic_ModuleConfig_MQTTConfig_init_zero {0, "", "", "", 0, 0}
@@ -335,7 +340,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_StoreForwardConfig_init_zero {0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_RangeTestConfig_init_zero {0, 0, 0}
-#define meshtastic_ModuleConfig_TelemetryConfig_init_zero {0, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_TelemetryConfig_init_zero {0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_CannedMessageConfig_init_zero {0, 0, 0, 0, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, 0, 0, "", 0}
 
 /* Field tags (for use in manual encoding/decoding) */
@@ -387,6 +392,8 @@ extern "C" {
 #define meshtastic_ModuleConfig_TelemetryConfig_environment_measurement_enabled_tag 3
 #define meshtastic_ModuleConfig_TelemetryConfig_environment_screen_enabled_tag 4
 #define meshtastic_ModuleConfig_TelemetryConfig_environment_display_fahrenheit_tag 5
+#define meshtastic_ModuleConfig_TelemetryConfig_air_quality_enabled_tag 6
+#define meshtastic_ModuleConfig_TelemetryConfig_air_quality_interval_tag 7
 #define meshtastic_ModuleConfig_CannedMessageConfig_rotary1_enabled_tag 1
 #define meshtastic_ModuleConfig_CannedMessageConfig_inputbroker_pin_a_tag 2
 #define meshtastic_ModuleConfig_CannedMessageConfig_inputbroker_pin_b_tag 3
@@ -507,7 +514,9 @@ X(a, STATIC,   SINGULAR, UINT32,   device_update_interval,   1) \
 X(a, STATIC,   SINGULAR, UINT32,   environment_update_interval,   2) \
 X(a, STATIC,   SINGULAR, BOOL,     environment_measurement_enabled,   3) \
 X(a, STATIC,   SINGULAR, BOOL,     environment_screen_enabled,   4) \
-X(a, STATIC,   SINGULAR, BOOL,     environment_display_fahrenheit,   5)
+X(a, STATIC,   SINGULAR, BOOL,     environment_display_fahrenheit,   5) \
+X(a, STATIC,   SINGULAR, BOOL,     air_quality_enabled,   6) \
+X(a, STATIC,   SINGULAR, UINT32,   air_quality_interval,   7)
 #define meshtastic_ModuleConfig_TelemetryConfig_CALLBACK NULL
 #define meshtastic_ModuleConfig_TelemetryConfig_DEFAULT NULL
 
@@ -558,7 +567,7 @@ extern const pb_msgdesc_t meshtastic_ModuleConfig_CannedMessageConfig_msg;
 #define meshtastic_ModuleConfig_RemoteHardwareConfig_size 2
 #define meshtastic_ModuleConfig_SerialConfig_size 26
 #define meshtastic_ModuleConfig_StoreForwardConfig_size 22
-#define meshtastic_ModuleConfig_TelemetryConfig_size 18
+#define meshtastic_ModuleConfig_TelemetryConfig_size 26
 #define meshtastic_ModuleConfig_size             204
 
 #ifdef __cplusplus

src/mesh/generated/meshtastic/telemetry.pb.c

@@ -12,6 +12,9 @@ PB_BIND(meshtastic_DeviceMetrics, meshtastic_DeviceMetrics, AUTO)
 PB_BIND(meshtastic_EnvironmentMetrics, meshtastic_EnvironmentMetrics, AUTO)
 
 
+PB_BIND(meshtastic_AirQualityMetrics, meshtastic_AirQualityMetrics, AUTO)
+
+
 PB_BIND(meshtastic_Telemetry, meshtastic_Telemetry, AUTO)
 
 

src/mesh/generated/meshtastic/telemetry.pb.h

@@ -10,7 +10,7 @@
 #endif
 
 /* Enum definitions */
-/* TODO: REPLACE */
+/* Supported I2C Sensors for telemetry in Meshtastic */
 typedef enum _meshtastic_TelemetrySensorType {
     /* No external telemetry sensor explicitly set */
     meshtastic_TelemetrySensorType_SENSOR_UNSET = 0,
@@ -37,7 +37,9 @@ typedef enum _meshtastic_TelemetrySensorType {
     /* 3-Axis magnetic sensor */
     meshtastic_TelemetrySensorType_QMC5883L = 11,
     /* High accuracy temperature and humidity */
-    meshtastic_TelemetrySensorType_SHT31 = 12
+    meshtastic_TelemetrySensorType_SHT31 = 12,
+    /* PM2.5 air quality sensor */
+    meshtastic_TelemetrySensorType_PMSA003I = 13
 } meshtastic_TelemetrySensorType;
 
 /* Struct definitions */
@@ -69,6 +71,34 @@ typedef struct _meshtastic_EnvironmentMetrics {
     float current;
 } meshtastic_EnvironmentMetrics;
 
+/* Air quality metrics */
+typedef struct _meshtastic_AirQualityMetrics {
+    /* Concentration Units Standard PM1.0 */
+    uint32_t pm10_standard;
+    /* Concentration Units Standard PM2.5 */
+    uint32_t pm25_standard;
+    /* Concentration Units Standard PM10.0 */
+    uint32_t pm100_standard;
+    /* Concentration Units Environmental PM1.0 */
+    uint32_t pm10_environmental;
+    /* Concentration Units Environmental PM2.5 */
+    uint32_t pm25_environmental;
+    /* Concentration Units Environmental PM10.0 */
+    uint32_t pm100_environmental;
+    /* 0.3um Particle Count */
+    uint32_t particles_03um;
+    /* 0.5um Particle Count */
+    uint32_t particles_05um;
+    /* 1.0um Particle Count */
+    uint32_t particles_10um;
+    /* 2.5um Particle Count */
+    uint32_t particles_25um;
+    /* 5.0um Particle Count */
+    uint32_t particles_50um;
+    /* 10.0um Particle Count */
+    uint32_t particles_100um;
+} meshtastic_AirQualityMetrics;
+
 /* Types of Measurements the telemetry module is equipped to handle */
 typedef struct _meshtastic_Telemetry {
     /* This is usually not sent over the mesh (to save space), but it is sent
@@ -83,6 +113,8 @@ typedef struct _meshtastic_Telemetry {
         meshtastic_DeviceMetrics device_metrics;
         /* Weather station or other environmental metrics */
         meshtastic_EnvironmentMetrics environment_metrics;
+        /* Air quality metrics */
+        meshtastic_AirQualityMetrics air_quality_metrics;
     } variant;
 } meshtastic_Telemetry;
 
@@ -93,8 +125,9 @@ extern "C" {
 
 /* Helper constants for enums */
 #define _meshtastic_TelemetrySensorType_MIN meshtastic_TelemetrySensorType_SENSOR_UNSET
-#define _meshtastic_TelemetrySensorType_MAX meshtastic_TelemetrySensorType_SHT31
-#define _meshtastic_TelemetrySensorType_ARRAYSIZE ((meshtastic_TelemetrySensorType)(meshtastic_TelemetrySensorType_SHT31+1))
+#define _meshtastic_TelemetrySensorType_MAX meshtastic_TelemetrySensorType_PMSA003I
+#define _meshtastic_TelemetrySensorType_ARRAYSIZE ((meshtastic_TelemetrySensorType)(meshtastic_TelemetrySensorType_PMSA003I+1))
+
 
 
 
@@ -103,9 +136,11 @@ extern "C" {
 /* Initializer values for message structs */
 #define meshtastic_DeviceMetrics_init_default    {0, 0, 0, 0}
 #define meshtastic_EnvironmentMetrics_init_default {0, 0, 0, 0, 0, 0}
+#define meshtastic_AirQualityMetrics_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Telemetry_init_default        {0, 0, {meshtastic_DeviceMetrics_init_default}}
 #define meshtastic_DeviceMetrics_init_zero       {0, 0, 0, 0}
 #define meshtastic_EnvironmentMetrics_init_zero  {0, 0, 0, 0, 0, 0}
+#define meshtastic_AirQualityMetrics_init_zero   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Telemetry_init_zero           {0, 0, {meshtastic_DeviceMetrics_init_zero}}
 
 /* Field tags (for use in manual encoding/decoding) */
@@ -119,9 +154,22 @@ extern "C" {
 #define meshtastic_EnvironmentMetrics_gas_resistance_tag 4
 #define meshtastic_EnvironmentMetrics_voltage_tag 5
 #define meshtastic_EnvironmentMetrics_current_tag 6
+#define meshtastic_AirQualityMetrics_pm10_standard_tag 1
+#define meshtastic_AirQualityMetrics_pm25_standard_tag 2
+#define meshtastic_AirQualityMetrics_pm100_standard_tag 3
+#define meshtastic_AirQualityMetrics_pm10_environmental_tag 4
+#define meshtastic_AirQualityMetrics_pm25_environmental_tag 5
+#define meshtastic_AirQualityMetrics_pm100_environmental_tag 6
+#define meshtastic_AirQualityMetrics_particles_03um_tag 7
+#define meshtastic_AirQualityMetrics_particles_05um_tag 8
+#define meshtastic_AirQualityMetrics_particles_10um_tag 9
+#define meshtastic_AirQualityMetrics_particles_25um_tag 10
+#define meshtastic_AirQualityMetrics_particles_50um_tag 11
+#define meshtastic_AirQualityMetrics_particles_100um_tag 12
 #define meshtastic_Telemetry_time_tag            1
 #define meshtastic_Telemetry_device_metrics_tag  2
 #define meshtastic_Telemetry_environment_metrics_tag 3
+#define meshtastic_Telemetry_air_quality_metrics_tag 4
 
 /* Struct field encoding specification for nanopb */
 #define meshtastic_DeviceMetrics_FIELDLIST(X, a) \
@@ -142,28 +190,49 @@ X(a, STATIC,   SINGULAR, FLOAT,    current,           6)
 #define meshtastic_EnvironmentMetrics_CALLBACK NULL
 #define meshtastic_EnvironmentMetrics_DEFAULT NULL
 
+#define meshtastic_AirQualityMetrics_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   pm10_standard,     1) \
+X(a, STATIC,   SINGULAR, UINT32,   pm25_standard,     2) \
+X(a, STATIC,   SINGULAR, UINT32,   pm100_standard,    3) \
+X(a, STATIC,   SINGULAR, UINT32,   pm10_environmental,   4) \
+X(a, STATIC,   SINGULAR, UINT32,   pm25_environmental,   5) \
+X(a, STATIC,   SINGULAR, UINT32,   pm100_environmental,   6) \
+X(a, STATIC,   SINGULAR, UINT32,   particles_03um,    7) \
+X(a, STATIC,   SINGULAR, UINT32,   particles_05um,    8) \
+X(a, STATIC,   SINGULAR, UINT32,   particles_10um,    9) \
+X(a, STATIC,   SINGULAR, UINT32,   particles_25um,   10) \
+X(a, STATIC,   SINGULAR, UINT32,   particles_50um,   11) \
+X(a, STATIC,   SINGULAR, UINT32,   particles_100um,  12)
+#define meshtastic_AirQualityMetrics_CALLBACK NULL
+#define meshtastic_AirQualityMetrics_DEFAULT NULL
+
 #define meshtastic_Telemetry_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, FIXED32,  time,              1) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (variant,device_metrics,variant.device_metrics),   2) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (variant,environment_metrics,variant.environment_metrics),   3)
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,environment_metrics,variant.environment_metrics),   3) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,air_quality_metrics,variant.air_quality_metrics),   4)
 #define meshtastic_Telemetry_CALLBACK NULL
 #define meshtastic_Telemetry_DEFAULT NULL
 #define meshtastic_Telemetry_variant_device_metrics_MSGTYPE meshtastic_DeviceMetrics
 #define meshtastic_Telemetry_variant_environment_metrics_MSGTYPE meshtastic_EnvironmentMetrics
+#define meshtastic_Telemetry_variant_air_quality_metrics_MSGTYPE meshtastic_AirQualityMetrics
 
 extern const pb_msgdesc_t meshtastic_DeviceMetrics_msg;
 extern const pb_msgdesc_t meshtastic_EnvironmentMetrics_msg;
+extern const pb_msgdesc_t meshtastic_AirQualityMetrics_msg;
 extern const pb_msgdesc_t meshtastic_Telemetry_msg;
 
 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
 #define meshtastic_DeviceMetrics_fields &meshtastic_DeviceMetrics_msg
 #define meshtastic_EnvironmentMetrics_fields &meshtastic_EnvironmentMetrics_msg
+#define meshtastic_AirQualityMetrics_fields &meshtastic_AirQualityMetrics_msg
 #define meshtastic_Telemetry_fields &meshtastic_Telemetry_msg
 
 /* Maximum encoded size of messages (where known) */
+#define meshtastic_AirQualityMetrics_size        72
 #define meshtastic_DeviceMetrics_size            21
 #define meshtastic_EnvironmentMetrics_size       30
-#define meshtastic_Telemetry_size                37
+#define meshtastic_Telemetry_size                79
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/http/WiFiAPClient.cpp

@@ -39,6 +39,9 @@ unsigned long lastrun_ntp = 0;
 
 bool needReconnect = true; // If we create our reconnector, run it once at the beginning
 
+WiFiUDP syslogClient;
+Syslog syslog(syslogClient);
+
 Periodic *wifiReconnect;
 
 static int32_t reconnectWiFi()
@@ -135,6 +138,26 @@ static void onNetworkConnected()
         timeClient.setUpdateInterval(60 * 60); // Update once an hour
 #endif
 
+        if (config.network.rsyslog_server[0]) {
+            LOG_INFO("Starting Syslog client\n");
+            // Defaults
+            int serverPort = 514;
+            const char *serverAddr = config.network.rsyslog_server;
+            String server = String(serverAddr);
+            int delimIndex = server.indexOf(':');
+            if (delimIndex > 0) {
+                String port = server.substring(delimIndex + 1, server.length());
+                server[delimIndex] = 0;
+                serverPort = port.toInt();
+                serverAddr = server.c_str();
+            }
+            syslog.server(serverAddr, serverPort);
+            syslog.deviceHostname(getDeviceName());
+            syslog.appName("Meshtastic");
+            syslog.defaultPriority(LOGLEVEL_USER);
+            syslog.enable();
+        }
+
         initWebServer();
         initApiServer();
 
@@ -223,6 +246,7 @@ static void WiFiEvent(WiFiEvent_t event)
         break;
     case ARDUINO_EVENT_WIFI_STA_STOP:
         LOG_INFO("WiFi station stopped\n");
+        syslog.disable();
         break;
     case ARDUINO_EVENT_WIFI_STA_CONNECTED:
         LOG_INFO("Connected to access point\n");
@@ -230,6 +254,7 @@ static void WiFiEvent(WiFiEvent_t event)
     case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
         LOG_INFO("Disconnected from WiFi access point\n");
         WiFi.disconnect(false, true);
+        syslog.disable();
         needReconnect = true;
         wifiReconnect->setIntervalFromNow(1000);
         break;
@@ -246,6 +271,7 @@ static void WiFiEvent(WiFiEvent_t event)
     case ARDUINO_EVENT_WIFI_STA_LOST_IP:
         LOG_INFO("Lost IP address and IP address is reset to 0\n");
         WiFi.disconnect(false, true);
+        syslog.disable();
         needReconnect = true;
         wifiReconnect->setIntervalFromNow(1000);
         break;

src/modules/AdminModule.cpp

@@ -2,17 +2,24 @@
 #include "Channels.h"
 #include "MeshService.h"
 #include "NodeDB.h"
+#include "PowerFSM.h"
 #ifdef ARCH_ESP32
 #include "BleOta.h"
 #endif
 #include "Router.h"
 #include "configuration.h"
 #include "main.h"
-
+#ifdef ARCH_NRF52
+#include "main.h"
+#endif
 #ifdef ARCH_PORTDUINO
 #include "unistd.h"
 #endif
 
+#if HAS_WIFI || HAS_ETHERNET
+#include "mqtt/MQTT.h"
+#endif
+
 #define DEFAULT_REBOOT_SECONDS 5
 
 AdminModule *adminModule;
@@ -99,6 +106,10 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
         else
             handleSetChannel(r->set_channel);
         break;
+    case meshtastic_AdminMessage_set_ham_mode_tag:
+        LOG_INFO("Client is setting ham mode\n");
+        handleSetHamMode(r->set_ham_mode);
+        break;
 
     /**
      * Other
@@ -159,6 +170,11 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
         saveChanges(SEGMENT_CONFIG | SEGMENT_MODULECONFIG | SEGMENT_DEVICESTATE | SEGMENT_CHANNELS);
         break;
     }
+    case meshtastic_AdminMessage_get_device_connection_status_request_tag: {
+        LOG_INFO("Client is getting device connection status\n");
+        handleGetDeviceConnectionStatus(mp);
+        break;
+    }
 #ifdef ARCH_PORTDUINO
     case meshtastic_AdminMessage_exit_simulator_tag:
         LOG_INFO("Exiting simulator\n");
@@ -196,7 +212,6 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
 void AdminModule::handleSetOwner(const meshtastic_User &o)
 {
     int changed = 0;
-    bool licensed_changed = false;
 
     if (*o.long_name) {
         changed |= strcmp(owner.long_name, o.long_name);
@@ -212,14 +227,12 @@ void AdminModule::handleSetOwner(const meshtastic_User &o)
     }
     if (owner.is_licensed != o.is_licensed) {
         changed = 1;
-        licensed_changed = true;
         owner.is_licensed = o.is_licensed;
-        config.lora.override_duty_cycle = owner.is_licensed; // override duty cycle for licensed operators
     }
 
     if (changed) { // If nothing really changed, don't broadcast on the network or write to flash
         service.reloadOwner(!hasOpenEditTransaction);
-        licensed_changed ? saveChanges(SEGMENT_CONFIG | SEGMENT_DEVICESTATE) : saveChanges(SEGMENT_DEVICESTATE);
+        saveChanges(SEGMENT_DEVICESTATE);
     }
 }
 
@@ -477,22 +490,72 @@ void AdminModule::handleGetModuleConfig(const meshtastic_MeshPacket &req, const
 void AdminModule::handleGetDeviceMetadata(const meshtastic_MeshPacket &req)
 {
     meshtastic_AdminMessage r = meshtastic_AdminMessage_init_default;
-
-    meshtastic_DeviceMetadata deviceMetadata;
-    strncpy(deviceMetadata.firmware_version, myNodeInfo.firmware_version, 18);
-    deviceMetadata.device_state_version = DEVICESTATE_CUR_VER;
-    deviceMetadata.canShutdown = pmu_found || HAS_CPU_SHUTDOWN;
-    deviceMetadata.hasBluetooth = HAS_BLUETOOTH;
-    deviceMetadata.hasWifi = HAS_WIFI;
-    deviceMetadata.hasEthernet = HAS_ETHERNET;
-    deviceMetadata.role = config.device.role;
-    deviceMetadata.position_flags = config.position.position_flags;
-
-    r.get_device_metadata_response = deviceMetadata;
+    r.get_device_metadata_response = getDeviceMetadata();
     r.which_payload_variant = meshtastic_AdminMessage_get_device_metadata_response_tag;
     myReply = allocDataProtobuf(r);
 }
 
+void AdminModule::handleGetDeviceConnectionStatus(const meshtastic_MeshPacket &req)
+{
+    meshtastic_AdminMessage r = meshtastic_AdminMessage_init_default;
+
+    meshtastic_DeviceConnectionStatus conn;
+
+    conn.wifi = {0};
+#if HAS_WIFI
+    conn.has_wifi = true;
+    conn.wifi.has_status = true;
+#ifdef ARCH_PORTDUINO
+    conn.wifi.status.is_connected = true;
+#else
+    conn.wifi.status.is_connected = WiFi.status() != WL_CONNECTED;
+#endif
+    strncpy(conn.wifi.ssid, config.network.wifi_ssid, 33);
+    if (conn.wifi.status.is_connected) {
+        conn.wifi.rssi = WiFi.RSSI();
+        conn.wifi.status.ip_address = WiFi.localIP();
+        conn.wifi.status.is_mqtt_connected = mqtt && mqtt->connected();
+        conn.wifi.status.is_syslog_connected = false; // FIXME wire this up
+    }
+#else
+    conn.has_wifi = false;
+#endif
+
+    conn.ethernet = {0};
+#if HAS_ETHERNET
+    conn.has_ethernet = true;
+    conn.ethernet.has_status = true;
+    if (Ethernet.linkStatus() == LinkON) {
+        conn.ethernet.status.is_connected = true;
+        conn.ethernet.status.ip_address = Ethernet.localIP();
+        conn.ethernet.status.is_mqtt_connected = mqtt && mqtt->connected();
+        conn.ethernet.status.is_syslog_connected = false; // FIXME wire this up
+    } else {
+        conn.ethernet.status.is_connected = false;
+    }
+#else
+    conn.has_ethernet = false;
+#endif
+
+#if HAS_BLUETOOTH
+    conn.has_bluetooth = true;
+    conn.bluetooth.pin = config.bluetooth.fixed_pin;
+#endif
+#ifdef ARCH_ESP32
+    conn.bluetooth.is_connected = nimbleBluetooth->isConnected();
+    conn.bluetooth.rssi = nimbleBluetooth->getRssi();
+#elif defined(ARCH_NRF52)
+    conn.bluetooth.is_connected = nrf52Bluetooth->isConnected();
+#endif
+    conn.has_serial = true; // No serial-less devices
+    conn.serial.is_connected = powerFSM.getState() == &stateSERIAL;
+    conn.serial.baud = SERIAL_BAUD;
+
+    r.get_device_connection_status_response = conn;
+    r.which_payload_variant = meshtastic_AdminMessage_get_device_connection_status_response_tag;
+    myReply = allocDataProtobuf(r);
+}
+
 void AdminModule::handleGetChannel(const meshtastic_MeshPacket &req, uint32_t channelIndex)
 {
     if (req.decoded.want_response) {
@@ -524,6 +587,32 @@ void AdminModule::saveChanges(int saveWhat, bool shouldReboot)
     }
 }
 
+void AdminModule::handleSetHamMode(const meshtastic_HamParameters &p)
+{
+    // Set call sign and override lora limitations for licensed use
+    strncpy(owner.long_name, p.call_sign, sizeof(owner.long_name));
+    strncpy(owner.short_name, p.short_name, sizeof(owner.short_name));
+    owner.is_licensed = true;
+    config.lora.override_duty_cycle = true;
+    config.lora.tx_power = p.tx_power;
+    config.lora.override_frequency = p.frequency;
+    // Set node info broadcast interval to 10 minutes
+    // For FCC minimum call-sign announcement
+    config.device.node_info_broadcast_secs = 600;
+
+    config.device.rebroadcast_mode = meshtastic_Config_DeviceConfig_RebroadcastMode_LOCAL_ONLY;
+    // Remove PSK of primary channel for plaintext amateur usage
+    auto primaryChannel = channels.getByIndex(channels.getPrimaryIndex());
+    auto &channelSettings = primaryChannel.settings;
+    channelSettings.psk.bytes[0] = 0;
+    channelSettings.psk.size = 0;
+    channels.setChannel(primaryChannel);
+    channels.onConfigChanged();
+
+    service.reloadOwner(false);
+    service.reloadConfig(SEGMENT_CONFIG | SEGMENT_DEVICESTATE | SEGMENT_CHANNELS);
+}
+
 AdminModule::AdminModule() : ProtobufModule("Admin", meshtastic_PortNum_ADMIN_APP, &meshtastic_AdminMessage_msg)
 {
     // restrict to the admin channel for rx

src/modules/AdminModule.h

@@ -1,5 +1,8 @@
 #pragma once
 #include "ProtobufModule.h"
+#ifdef ARCH_ESP32
+#include "mesh/http/WiFiAPClient.h"
+#endif
 
 /**
  * Admin module for admin messages
@@ -31,7 +34,7 @@ class AdminModule : public ProtobufModule<meshtastic_AdminMessage>
     void handleGetModuleConfig(const meshtastic_MeshPacket &req, uint32_t configType);
     void handleGetChannel(const meshtastic_MeshPacket &req, uint32_t channelIndex);
     void handleGetDeviceMetadata(const meshtastic_MeshPacket &req);
-
+    void handleGetDeviceConnectionStatus(const meshtastic_MeshPacket &req);
     /**
      * Setters
      */
@@ -40,6 +43,7 @@ class AdminModule : public ProtobufModule<meshtastic_AdminMessage>
     void handleSetConfig(const meshtastic_Config &c);
     void handleSetModuleConfig(const meshtastic_ModuleConfig &c);
     void handleSetChannel();
+    void handleSetHamMode(const meshtastic_HamParameters &req);
     void reboot(int32_t seconds);
 };
 

src/modules/Modules.cpp

@@ -15,6 +15,9 @@
 #include "modules/WaypointModule.h"
 #if HAS_TELEMETRY
 #include "modules/Telemetry/DeviceTelemetry.h"
+#endif
+#if HAS_SENSOR
+#include "modules/Telemetry/AirQualityTelemetry.h"
 #include "modules/Telemetry/EnvironmentTelemetry.h"
 #endif
 #ifdef ARCH_ESP32
@@ -62,7 +65,12 @@ void setupModules()
 #endif
 #if HAS_TELEMETRY
         new DeviceTelemetryModule();
+#endif
+#if HAS_SENSOR
         new EnvironmentTelemetryModule();
+        if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_PMSA003I] > 0) {
+            new AirQualityTelemetryModule();
+        }
 #endif
 #if (defined(ARCH_ESP32) || defined(ARCH_NRF52)) && !defined(TTGO_T_ECHO) && !defined(CONFIG_IDF_TARGET_ESP32S2)
         new SerialModule();

src/modules/NodeInfoModule.cpp

@@ -34,20 +34,32 @@ void NodeInfoModule::sendOurNodeInfo(NodeNum dest, bool wantReplies)
         service.cancelSending(prevPacketId);
 
     meshtastic_MeshPacket *p = allocReply();
-    p->to = dest;
-    p->decoded.want_response = wantReplies;
-    p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
-    prevPacketId = p->id;
+    if (p) { // Check whether we didn't ignore it
+        p->to = dest;
+        p->decoded.want_response = wantReplies;
+        p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
+        prevPacketId = p->id;
 
-    service.sendToMesh(p);
+        service.sendToMesh(p);
+    }
 }
 
 meshtastic_MeshPacket *NodeInfoModule::allocReply()
 {
-    meshtastic_User &u = owner;
+    uint32_t now = millis();
+    // If we sent our NodeInfo less than 1 min. ago, don't send it again as it may be still underway.
+    if (lastSentToMesh && (now - lastSentToMesh) < 60 * 1000) {
+        LOG_DEBUG("Sending NodeInfo will be ignored since we just sent it.\n");
+        ignoreRequest = true; // Mark it as ignored for MeshModule
+        return NULL;
+    } else {
+        ignoreRequest = false; // Don't ignore requests anymore
+        meshtastic_User &u = owner;
 
-    LOG_INFO("sending owner %s/%s/%s\n", u.id, u.long_name, u.short_name);
-    return allocDataProtobuf(u);
+        LOG_INFO("sending owner %s/%s/%s\n", u.id, u.long_name, u.short_name);
+        lastSentToMesh = now;
+        return allocDataProtobuf(u);
+    }
 }
 
 NodeInfoModule::NodeInfoModule()
@@ -71,5 +83,5 @@ int32_t NodeInfoModule::runOnce()
         sendOurNodeInfo(NODENUM_BROADCAST, requestReplies); // Send our info (don't request replies)
     }
 
-    return default_broadcast_interval_secs * 1000;
+    return getConfiguredOrDefaultMs(config.device.node_info_broadcast_secs, default_broadcast_interval_secs);
 }

src/modules/NodeInfoModule.h

@@ -35,6 +35,9 @@ class NodeInfoModule : public ProtobufModule<meshtastic_User>, private concurren
 
     /** Does our periodic broadcast */
     virtual int32_t runOnce() override;
+
+  private:
+    uint32_t lastSentToMesh = 0; // Last time we sent our NodeInfo to the mesh
 };
 
 extern NodeInfoModule *nodeInfoModule;

src/modules/RoutingModule.cpp

@@ -46,5 +46,5 @@ void RoutingModule::sendAckNak(meshtastic_Routing_Error err, NodeNum to, PacketI
 RoutingModule::RoutingModule() : ProtobufModule("routing", meshtastic_PortNum_ROUTING_APP, &meshtastic_Routing_msg)
 {
     isPromiscuous = true;
-    encryptedOk = true;
+    encryptedOk = config.device.rebroadcast_mode != meshtastic_Config_DeviceConfig_RebroadcastMode_LOCAL_ONLY;
 }

src/modules/Telemetry/AirQualityTelemetry.cpp

@@ -0,0 +1,129 @@
+#include "AirQualityTelemetry.h"
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "PowerFSM.h"
+#include "RTC.h"
+#include "Router.h"
+#include "configuration.h"
+#include "main.h"
+
+int32_t AirQualityTelemetryModule::runOnce()
+{
+    int32_t result = INT32_MAX;
+    /*
+        Uncomment the preferences below if you want to use the module
+        without having to configure it from the PythonAPI or WebUI.
+    */
+
+    // moduleConfig.telemetry.air_quality_enabled = 1;
+
+    if (!(moduleConfig.telemetry.air_quality_enabled)) {
+        // If this module is not enabled, and the user doesn't want the display screen don't waste any OSThread time on it
+        return disable();
+    }
+
+    if (firstTime) {
+        // This is the first time the OSThread library has called this function, so do some setup
+        firstTime = 0;
+
+        if (moduleConfig.telemetry.air_quality_enabled) {
+            LOG_INFO("Air quality Telemetry: Initializing\n");
+            if (!aqi.begin_I2C()) {
+                LOG_WARN("Could not establish i2c connection to AQI sensor\n");
+                return disable();
+            }
+            return 1000;
+        }
+        return result;
+    } else {
+        // if we somehow got to a second run of this module with measurement disabled, then just wait forever
+        if (!moduleConfig.telemetry.air_quality_enabled)
+            return result;
+
+        uint32_t now = millis();
+        if (((lastSentToMesh == 0) ||
+             ((now - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.telemetry.air_quality_interval))) &&
+            airTime->isTxAllowedAirUtil()) {
+            sendTelemetry();
+            lastSentToMesh = now;
+        } else if (service.isToPhoneQueueEmpty()) {
+            // Just send to phone when it's not our time to send to mesh yet
+            // Only send while queue is empty (phone assumed connected)
+            sendTelemetry(NODENUM_BROADCAST, true);
+        }
+    }
+    return sendToPhoneIntervalMs;
+}
+
+bool AirQualityTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *t)
+{
+    if (t->which_variant == meshtastic_Telemetry_air_quality_metrics_tag) {
+        const char *sender = getSenderShortName(mp);
+
+        LOG_INFO("(Received from %s): pm10_standard=%i, pm25_standard=%i, pm100_standard=%i\n", sender,
+                 t->variant.air_quality_metrics.pm10_standard, t->variant.air_quality_metrics.pm25_standard,
+                 t->variant.air_quality_metrics.pm100_standard);
+
+        LOG_INFO("                  | PM1.0(Environmental)=%i, PM2.5(Environmental)=%i, PM10.0(Environmental)=%i\n",
+                 t->variant.air_quality_metrics.pm10_environmental, t->variant.air_quality_metrics.pm25_environmental,
+                 t->variant.air_quality_metrics.pm100_environmental);
+
+        // release previous packet before occupying a new spot
+        if (lastMeasurementPacket != nullptr)
+            packetPool.release(lastMeasurementPacket);
+
+        lastMeasurementPacket = packetPool.allocCopy(mp);
+    }
+
+    return false; // Let others look at this message also if they want
+}
+
+bool AirQualityTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
+{
+    if (!aqi.read(&data)) {
+        LOG_WARN("Skipping send measurements. Could not read AQIn\n");
+        return false;
+    }
+
+    meshtastic_Telemetry m;
+    m.time = getTime();
+    m.which_variant = meshtastic_Telemetry_air_quality_metrics_tag;
+    m.variant.air_quality_metrics.pm10_standard = data.pm10_standard;
+    m.variant.air_quality_metrics.pm25_standard = data.pm25_standard;
+    m.variant.air_quality_metrics.pm100_standard = data.pm100_standard;
+
+    m.variant.air_quality_metrics.pm10_environmental = data.pm10_env;
+    m.variant.air_quality_metrics.pm25_environmental = data.pm25_env;
+    m.variant.air_quality_metrics.pm100_environmental = data.pm100_env;
+
+    LOG_INFO("(Sending): PM1.0(Standard)=%i, PM2.5(Standard)=%i, PM10.0(Standard)=%i\n",
+             m.variant.air_quality_metrics.pm10_standard, m.variant.air_quality_metrics.pm25_standard,
+             m.variant.air_quality_metrics.pm100_standard);
+
+    LOG_INFO("         | PM1.0(Environmental)=%i, PM2.5(Environmental)=%i, PM10.0(Environmental)=%i\n",
+             m.variant.air_quality_metrics.pm10_environmental, m.variant.air_quality_metrics.pm25_environmental,
+             m.variant.air_quality_metrics.pm100_environmental);
+
+    meshtastic_MeshPacket *p = allocDataProtobuf(m);
+    p->to = dest;
+    p->decoded.want_response = false;
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR)
+        p->priority = meshtastic_MeshPacket_Priority_RELIABLE;
+    else
+        p->priority = meshtastic_MeshPacket_Priority_MIN;
+
+    // release previous packet before occupying a new spot
+    if (lastMeasurementPacket != nullptr)
+        packetPool.release(lastMeasurementPacket);
+
+    lastMeasurementPacket = packetPool.allocCopy(*p);
+    if (phoneOnly) {
+        LOG_INFO("Sending packet to phone\n");
+        service.sendToPhone(p);
+    } else {
+        LOG_INFO("Sending packet to mesh\n");
+        service.sendToMesh(p, RX_SRC_LOCAL, true);
+    }
+    return true;
+}

src/modules/Telemetry/AirQualityTelemetry.h

@@ -0,0 +1,37 @@
+#pragma once
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "Adafruit_PM25AQI.h"
+#include "NodeDB.h"
+#include "ProtobufModule.h"
+
+class AirQualityTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
+{
+  public:
+    AirQualityTelemetryModule()
+        : concurrency::OSThread("AirQualityTelemetryModule"),
+          ProtobufModule("AirQualityTelemetry", meshtastic_PortNum_TELEMETRY_APP, &meshtastic_Telemetry_msg)
+    {
+        lastMeasurementPacket = nullptr;
+        setIntervalFromNow(10 * 1000);
+        aqi = Adafruit_PM25AQI();
+    }
+
+  protected:
+    /** Called to handle a particular incoming message
+    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    */
+    virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *p) override;
+    virtual int32_t runOnce() override;
+    /**
+     * Send our Telemetry into the mesh
+     */
+    bool sendTelemetry(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
+
+  private:
+    Adafruit_PM25AQI aqi;
+    PM25_AQI_Data data = {0};
+    bool firstTime = 1;
+    meshtastic_MeshPacket *lastMeasurementPacket;
+    uint32_t sendToPhoneIntervalMs = SECONDS_IN_MINUTE * 1000; // Send to phone every minute
+    uint32_t lastSentToMesh = 0;
+};

src/modules/Telemetry/DeviceTelemetry.cpp

@@ -13,8 +13,8 @@
 int32_t DeviceTelemetryModule::runOnce()
 {
     uint32_t now = millis();
-    if ((lastSentToMesh == 0 ||
-         (now - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.telemetry.device_update_interval)) &&
+    if (((lastSentToMesh == 0) ||
+         ((now - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.telemetry.device_update_interval))) &&
         airTime->isTxAllowedChannelUtil() && airTime->isTxAllowedAirUtil()) {
         sendTelemetry();
         lastSentToMesh = now;
@@ -35,8 +35,6 @@ bool DeviceTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &
                  t->variant.device_metrics.air_util_tx, t->variant.device_metrics.channel_utilization,
                  t->variant.device_metrics.battery_level, t->variant.device_metrics.voltage);
 
-        lastMeasurementPacket = packetPool.allocCopy(mp);
-
         nodeDB.updateTelemetry(getFrom(&mp), *t, RX_SRC_RADIO);
     }
     return false; // Let others look at this message also if they want
@@ -63,7 +61,6 @@ bool DeviceTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
     p->decoded.want_response = false;
     p->priority = meshtastic_MeshPacket_Priority_MIN;
 
-    lastMeasurementPacket = packetPool.allocCopy(*p);
     nodeDB.updateTelemetry(nodeDB.getNodeNum(), t, RX_SRC_LOCAL);
     if (phoneOnly) {
         LOG_INFO("Sending packet to phone\n");

src/modules/Telemetry/DeviceTelemetry.h

@@ -12,8 +12,7 @@ class DeviceTelemetryModule : private concurrency::OSThread, public ProtobufModu
         : concurrency::OSThread("DeviceTelemetryModule"),
           ProtobufModule("DeviceTelemetry", meshtastic_PortNum_TELEMETRY_APP, &meshtastic_Telemetry_msg)
     {
-        lastMeasurementPacket = nullptr;
-        setIntervalFromNow(10 * 1000);
+        setIntervalFromNow(45 * 1000); // Wait until NodeInfo is sent
     }
     virtual bool wantUIFrame() { return false; }
 
@@ -31,5 +30,4 @@ class DeviceTelemetryModule : private concurrency::OSThread, public ProtobufModu
   private:
     uint32_t sendToPhoneIntervalMs = SECONDS_IN_MINUTE * 1000; // Send to phone every minute
     uint32_t lastSentToMesh = 0;
-    const meshtastic_MeshPacket *lastMeasurementPacket;
 };

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -52,7 +52,6 @@ SHT31Sensor sht31Sensor;
 
 int32_t EnvironmentTelemetryModule::runOnce()
 {
-#ifndef ARCH_PORTDUINO
     int32_t result = INT32_MAX;
     /*
         Uncomment the preferences below if you want to use the module
@@ -103,8 +102,8 @@ int32_t EnvironmentTelemetryModule::runOnce()
             return result;
 
         uint32_t now = millis();
-        if ((lastSentToMesh == 0 ||
-             (now - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval)) &&
+        if (((lastSentToMesh == 0) ||
+             ((now - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval))) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();
             lastSentToMesh = now;
@@ -115,7 +114,16 @@ int32_t EnvironmentTelemetryModule::runOnce()
         }
     }
     return sendToPhoneIntervalMs;
-#endif
+}
+
+bool EnvironmentTelemetryModule::wantUIFrame()
+{
+    return moduleConfig.telemetry.environment_screen_enabled;
+}
+
+float EnvironmentTelemetryModule::CelsiusToFahrenheit(float c)
+{
+    return (c * 9) / 5 + 32;
 }
 
 uint32_t GetTimeSinceMeshPacket(const meshtastic_MeshPacket *mp)
@@ -130,16 +138,6 @@ uint32_t GetTimeSinceMeshPacket(const meshtastic_MeshPacket *mp)
     return delta;
 }
 
-bool EnvironmentTelemetryModule::wantUIFrame()
-{
-    return moduleConfig.telemetry.environment_screen_enabled;
-}
-
-float EnvironmentTelemetryModule::CelsiusToFahrenheit(float c)
-{
-    return (c * 9) / 5 + 32;
-}
-
 void EnvironmentTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     display->setTextAlignment(TEXT_ALIGN_LEFT);
@@ -193,6 +191,10 @@ bool EnvironmentTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPac
                  t->variant.environment_metrics.gas_resistance, t->variant.environment_metrics.relative_humidity,
                  t->variant.environment_metrics.temperature, t->variant.environment_metrics.voltage);
 
+        // release previous packet before occupying a new spot
+        if (lastMeasurementPacket != nullptr)
+            packetPool.release(lastMeasurementPacket);
+
         lastMeasurementPacket = packetPool.allocCopy(mp);
     }
 
@@ -242,7 +244,13 @@ bool EnvironmentTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
     meshtastic_MeshPacket *p = allocDataProtobuf(m);
     p->to = dest;
     p->decoded.want_response = false;
-    p->priority = meshtastic_MeshPacket_Priority_MIN;
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR)
+        p->priority = meshtastic_MeshPacket_Priority_RELIABLE;
+    else
+        p->priority = meshtastic_MeshPacket_Priority_MIN;
+    // release previous packet before occupying a new spot
+    if (lastMeasurementPacket != nullptr)
+        packetPool.release(lastMeasurementPacket);
 
     lastMeasurementPacket = packetPool.allocCopy(*p);
     if (phoneOnly) {

src/modules/Telemetry/EnvironmentTelemetry.h

@@ -36,7 +36,7 @@ class EnvironmentTelemetryModule : private concurrency::OSThread, public Protobu
   private:
     float CelsiusToFahrenheit(float c);
     bool firstTime = 1;
-    const meshtastic_MeshPacket *lastMeasurementPacket;
+    meshtastic_MeshPacket *lastMeasurementPacket;
     uint32_t sendToPhoneIntervalMs = SECONDS_IN_MINUTE * 1000; // Send to phone every minute
     uint32_t lastSentToMesh = 0;
     uint32_t sensor_read_error_count = 0;

src/modules/esp32/RangeTestModule.cpp

@@ -56,7 +56,7 @@ int32_t RangeTestModule::runOnce()
                 return (5000); // Sending first message 5 seconds after initilization.
             } else {
                 LOG_INFO("Initializing Range Test Module -- Receiver\n");
-                return (INT32_MAX);
+                return disable();
                 // This thread does not need to run as a receiver
             }
 
@@ -91,17 +91,9 @@ int32_t RangeTestModule::runOnce()
     return disable();
 }
 
-meshtastic_MeshPacket *RangeTestModuleRadio::allocReply()
-{
-
-    auto reply = allocDataPacket(); // Allocate a packet for sending
-
-    return reply;
-}
-
 void RangeTestModuleRadio::sendPayload(NodeNum dest, bool wantReplies)
 {
-    meshtastic_MeshPacket *p = allocReply();
+    meshtastic_MeshPacket *p = allocDataPacket();
     p->to = dest;
     p->decoded.want_response = wantReplies;
 

src/modules/esp32/RangeTestModule.h

@@ -43,14 +43,7 @@ class RangeTestModuleRadio : public SinglePortModule
      */
     bool appendFile(const meshtastic_MeshPacket &mp);
 
-    /**
-     * Kevin's magical calculation of two points to meters.
-     */
-    float latLongToMeter(double lat_a, double lng_a, double lat_b, double lng_b);
-
   protected:
-    virtual meshtastic_MeshPacket *allocReply() override;
-
     /** Called to handle a particular incoming message
 
     @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for

src/mqtt/MQTT.cpp

@@ -15,11 +15,13 @@
 #include "mqtt/JSON.h"
 #include <assert.h>
 
+const int reconnectMax = 5;
+
 MQTT *mqtt;
 
-String statusTopic = "msh/2/stat/";
-String cryptTopic = "msh/2/c/";   // msh/2/c/CHANNELID/NODEID
-String jsonTopic = "msh/2/json/"; // msh/2/json/CHANNELID/NODEID
+std::string statusTopic = "msh/2/stat/";
+std::string cryptTopic = "msh/2/c/";   // msh/2/c/CHANNELID/NODEID
+std::string jsonTopic = "msh/2/json/"; // msh/2/json/CHANNELID/NODEID
 
 static MemoryDynamic<meshtastic_ServiceEnvelope> staticMqttPool;
 
@@ -218,15 +220,13 @@ void MQTT::reconnect()
             sendSubscriptions();
         } else {
 #if HAS_WIFI && !defined(ARCH_PORTDUINO)
-            LOG_ERROR("Failed to contact MQTT server (%d/5)...\n", reconnectCount + 1);
-            if (reconnectCount >= 4) {
+            reconnectCount++;
+            LOG_ERROR("Failed to contact MQTT server (%d/%d)...\n", reconnectCount, reconnectMax);
+            if (reconnectCount >= reconnectMax) {
                 needReconnect = true;
                 wifiReconnect->setIntervalFromNow(0);
                 reconnectCount = 0;
-            } else {
-                reconnectCount++;
             }
-
 #endif
         }
     }
@@ -238,11 +238,11 @@ void MQTT::sendSubscriptions()
     for (size_t i = 0; i < numChan; i++) {
         auto &ch = channels.getByIndex(i);
         if (ch.settings.downlink_enabled) {
-            String topic = cryptTopic + channels.getGlobalId(i) + "/#";
+            std::string topic = cryptTopic + channels.getGlobalId(i) + "/#";
             LOG_INFO("Subscribing to %s\n", topic.c_str());
             pubSub.subscribe(topic.c_str(), 1); // FIXME, is QOS 1 right?
             if (moduleConfig.mqtt.json_enabled == true) {
-                String topicDecoded = jsonTopic + channels.getGlobalId(i) + "/#";
+                std::string topicDecoded = jsonTopic + channels.getGlobalId(i) + "/#";
                 LOG_INFO("Subscribing to %s\n", topicDecoded.c_str());
                 pubSub.subscribe(topicDecoded.c_str(), 1); // FIXME, is QOS 1 right?
             }
@@ -296,7 +296,7 @@ int32_t MQTT::runOnce()
                     static uint8_t bytes[meshtastic_MeshPacket_size + 64];
                     size_t numBytes = pb_encode_to_bytes(bytes, sizeof(bytes), &meshtastic_ServiceEnvelope_msg, env);
 
-                    String topic = cryptTopic + env->channel_id + "/" + owner.id;
+                    std::string topic = cryptTopic + env->channel_id + "/" + owner.id;
                     LOG_INFO("publish %s, %u bytes from queue\n", topic.c_str(), numBytes);
 
                     pubSub.publish(topic.c_str(), bytes, numBytes, false);
@@ -305,7 +305,7 @@ int32_t MQTT::runOnce()
                         // handle json topic
                         auto jsonString = this->downstreamPacketToJson(env->packet);
                         if (jsonString.length() != 0) {
-                            String topicJson = jsonTopic + env->channel_id + "/" + owner.id;
+                            std::string topicJson = jsonTopic + env->channel_id + "/" + owner.id;
                             LOG_INFO("JSON publish message to %s, %u bytes: %s\n", topicJson.c_str(), jsonString.length(),
                                      jsonString.c_str());
                             pubSub.publish(topicJson.c_str(), jsonString.c_str(), false);
@@ -350,7 +350,7 @@ void MQTT::onSend(const meshtastic_MeshPacket &mp, ChannelIndex chIndex)
             static uint8_t bytes[meshtastic_MeshPacket_size + 64];
             size_t numBytes = pb_encode_to_bytes(bytes, sizeof(bytes), &meshtastic_ServiceEnvelope_msg, env);
 
-            String topic = cryptTopic + channelId + "/" + owner.id;
+            std::string topic = cryptTopic + channelId + "/" + owner.id;
             LOG_DEBUG("publish %s, %u bytes\n", topic.c_str(), numBytes);
 
             pubSub.publish(topic.c_str(), bytes, numBytes, false);
@@ -359,7 +359,7 @@ void MQTT::onSend(const meshtastic_MeshPacket &mp, ChannelIndex chIndex)
                 // handle json topic
                 auto jsonString = this->downstreamPacketToJson((meshtastic_MeshPacket *)&mp);
                 if (jsonString.length() != 0) {
-                    String topicJson = jsonTopic + channelId + "/" + owner.id;
+                    std::string topicJson = jsonTopic + channelId + "/" + owner.id;
                     LOG_INFO("JSON publish message to %s, %u bytes: %s\n", topicJson.c_str(), jsonString.length(),
                              jsonString.c_str());
                     pubSub.publish(topicJson.c_str(), jsonString.c_str(), false);
@@ -386,7 +386,7 @@ std::string MQTT::downstreamPacketToJson(meshtastic_MeshPacket *mp)
 {
     // the created jsonObj is immutable after creation, so
     // we need to do the heavy lifting before assembling it.
-    String msgType;
+    std::string msgType;
     JSONObject msgPayload;
     JSONObject jsonObj;
 

src/nimble/NimbleBluetooth.cpp

@@ -93,7 +93,6 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
             passkeyShowing = false;
             screen->stopBluetoothPinScreen();
         }
-        // bluetoothPhoneAPI->setInitialState();
     }
 
     virtual void onDisconnect(NimBLEServer *pServer, ble_gap_conn_desc *desc) { LOG_INFO("BLE disconnect\n"); }
@@ -117,6 +116,21 @@ bool NimbleBluetooth::isActive()
     return bleServer;
 }
 
+bool NimbleBluetooth::isConnected()
+{
+    return bleServer->getConnectedCount() > 0;
+}
+
+int NimbleBluetooth::getRssi()
+{
+    if (bleServer && isConnected()) {
+        auto service = bleServer->getServiceByUUID(MESH_SERVICE_UUID);
+        uint16_t handle = service->getHandle();
+        return NimBLEDevice::getClientByID(handle)->getRssi();
+    }
+    return 0; // FIXME figure out where to source this
+}
+
 void NimbleBluetooth::setup()
 {
     // Uncomment for testing
@@ -135,7 +149,6 @@ void NimbleBluetooth::setup()
 
     NimbleBluetoothServerCallback *serverCallbacks = new NimbleBluetoothServerCallback();
     bleServer->setCallbacks(serverCallbacks, true);
-
     setupService();
     startAdvertising();
 }

src/nimble/NimbleBluetooth.h

@@ -1,12 +1,15 @@
 #pragma once
+#include "BluetoothCommon.h"
 
-class NimbleBluetooth
+class NimbleBluetooth : BluetoothApi
 {
   public:
     void setup();
     void shutdown();
     void clearBonds();
     bool isActive();
+    bool isConnected();
+    int getRssi();
 
   private:
     void setupService();

src/platform/esp32/architecture.h

@@ -27,6 +27,9 @@
 #ifndef HAS_TELEMETRY
 #define HAS_TELEMETRY 1
 #endif
+#ifndef HAS_SENSOR
+#define HAS_SENSOR 1
+#endif
 #ifndef HAS_RADIO
 #define HAS_RADIO 1
 #endif
@@ -90,6 +93,12 @@
 #define HW_VENDOR meshtastic_HardwareModel_HELTEC_WSL_V3
 #elif defined(TLORA_T3S3_V1)
 #define HW_VENDOR meshtastic_HardwareModel_TLORA_T3_S3
+#elif defined(BETAFPV_2400_TX)
+#define HW_VENDOR meshtastic_HardwareModel_BETAFPV_2400_TX
+#elif defined(NANO_G1_EXPLORER)
+#define HW_VENDOR meshtastic_HardwareModel_NANO_G1_EXPLORER
+#elif defined(BETAFPV_900_TX_NANO)
+#define HW_VENDOR meshtastic_HardwareModel_BETAFPV_900_NANO_TX
 #endif
 
 //

src/platform/esp32/main-esp32.cpp

@@ -19,11 +19,9 @@
 #include <nvs_flash.h>
 
 #if !defined(CONFIG_IDF_TARGET_ESP32S2)
-NimbleBluetooth *nimbleBluetooth;
 
 void setBluetoothEnable(bool on)
 {
-
     if (!isWifiAvailable() && config.bluetooth.enabled == true) {
         if (!nimbleBluetooth) {
             nimbleBluetooth = new NimbleBluetooth();

src/platform/nrf52/NRF52Bluetooth.cpp

@@ -92,12 +92,12 @@ void startAdv(void)
     Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
 
     // IncludeService UUID
-    // Bluefruit.ScanResponse.addService(meshBleService);
+    Bluefruit.ScanResponse.addService(meshBleService);
     Bluefruit.ScanResponse.addTxPower();
     Bluefruit.ScanResponse.addName();
 
     // Include Name
-    // Bluefruit.Advertising.addName();
+    Bluefruit.Advertising.addName();
     Bluefruit.Advertising.addService(meshBleService);
 
     /* Start Advertising
@@ -213,6 +213,16 @@ void NRF52Bluetooth::shutdown()
     Bluefruit.Advertising.stop();
 }
 
+bool NRF52Bluetooth::isConnected()
+{
+    return Bluefruit.connected(connectionHandle);
+}
+
+int NRF52Bluetooth::getRssi()
+{
+    return 0; // FIXME figure out where to source this
+}
+
 void NRF52Bluetooth::setup()
 {
     // Initialise the Bluefruit module

src/platform/nrf52/NRF52Bluetooth.h

@@ -1,13 +1,16 @@
 #pragma once
 
+#include "BluetoothCommon.h"
 #include <Arduino.h>
 
-class NRF52Bluetooth
+class NRF52Bluetooth : BluetoothApi
 {
   public:
     void setup();
     void shutdown();
     void clearBonds();
+    bool isConnected();
+    int getRssi();
 
   private:
     static void onConnectionSecured(uint16_t conn_handle);

src/platform/nrf52/architecture.h

@@ -23,6 +23,9 @@
 #ifndef HAS_TELEMETRY
 #define HAS_TELEMETRY 1
 #endif
+#ifndef HAS_SENSOR
+#define HAS_SENSOR 1
+#endif
 #ifndef HAS_RADIO
 #define HAS_RADIO 1
 #endif

src/platform/nrf52/main-nrf52.cpp

@@ -8,9 +8,8 @@
 #include <stdio.h>
 // #include <Adafruit_USBD_Device.h>
 #include "NodeDB.h"
-
-#include "NRF52Bluetooth.h"
 #include "error.h"
+#include "main.h"
 
 #ifdef BQ25703A_ADDR
 #include "BQ25713.h"
@@ -63,8 +62,6 @@ static void initBrownout()
     // We don't bother with setting up brownout if soft device is disabled - because during production we always use softdevice
 }
 
-NRF52Bluetooth *nrf52Bluetooth;
-
 static bool bleOn = false;
 static const bool useSoftDevice = true; // Set to false for easier debugging
 

src/platform/portduino/SimRadio.cpp

@@ -2,7 +2,7 @@
 #include "MeshService.h"
 #include "Router.h"
 
-SimRadio::SimRadio()
+SimRadio::SimRadio() : NotifiedWorkerThread("SimRadio")
 {
     instance = this;
 }
@@ -53,10 +53,7 @@ void SimRadio::startTransmitTimer(bool withDelay)
     if (!txQueue.empty()) {
         uint32_t delayMsec = !withDelay ? 1 : getTxDelayMsec();
         // LOG_DEBUG("xmit timer %d\n", delay);
-        delay(delayMsec);
-        onNotify(TRANSMIT_DELAY_COMPLETED);
-    } else {
-        LOG_DEBUG("TX QUEUE EMPTY!\n");
+        notifyLater(delayMsec, TRANSMIT_DELAY_COMPLETED, false);
     }
 }
 
@@ -66,8 +63,7 @@ void SimRadio::startTransmitTimerSNR(float snr)
     if (!txQueue.empty()) {
         uint32_t delayMsec = getTxDelayMsecWeighted(snr);
         // LOG_DEBUG("xmit timer %d\n", delay);
-        delay(delayMsec);
-        onNotify(TRANSMIT_DELAY_COMPLETED);
+        notifyLater(delayMsec, TRANSMIT_DELAY_COMPLETED, false);
     }
 }
 
@@ -142,11 +138,12 @@ void SimRadio::onNotify(uint32_t notification)
     switch (notification) {
     case ISR_TX:
         handleTransmitInterrupt();
-        LOG_DEBUG("tx complete - starting timer\n");
+        //  LOG_DEBUG("tx complete - starting timer\n");
         startTransmitTimer();
         break;
     case ISR_RX:
-        LOG_DEBUG("rx complete - starting timer\n");
+        //  LOG_DEBUG("rx complete - starting timer\n");
+        startTransmitTimer();
         break;
     case TRANSMIT_DELAY_COMPLETED:
         LOG_DEBUG("delay done\n");
@@ -170,8 +167,7 @@ void SimRadio::onNotify(uint32_t notification)
                     uint32_t xmitMsec = getPacketTime(txp);
                     airTime->logAirtime(TX_LOG, xmitMsec);
 
-                    delay(xmitMsec); // Model the time it is busy sending
-                    completeSending();
+                    notifyLater(xmitMsec, ISR_TX, false); // Model the time it is busy sending
                 }
             }
         } else {
@@ -242,8 +238,7 @@ void SimRadio::handleReceiveInterrupt(meshtastic_MeshPacket *p)
     xmitMsec = getPacketTime(length);
     // LOG_DEBUG("Payload size %d vs length (includes header) %d\n", p->decoded.payload.size, length);
 
-    meshtastic_MeshPacket *mp = packetPool.allocCopy(*p);          // keep a copy in packtPool
-    mp->which_payload_variant = meshtastic_MeshPacket_decoded_tag; // Mark that the payload is already decoded
+    meshtastic_MeshPacket *mp = packetPool.allocCopy(*p); // keep a copy in packetPool
 
     printPacket("Lora RX", mp);
 
@@ -268,4 +263,4 @@ int16_t SimRadio::readData(uint8_t *data, size_t len)
     }
 
     return state;
-}
+}

src/platform/portduino/SimRadio.h

@@ -3,10 +3,11 @@
 #include "MeshPacketQueue.h"
 #include "RadioInterface.h"
 #include "api/WiFiServerAPI.h"
+#include "concurrency/NotifiedWorkerThread.h"
 
 #include <RadioLib.h>
 
-class SimRadio : public RadioInterface
+class SimRadio : public RadioInterface, protected concurrency::NotifiedWorkerThread
 {
     enum PendingISR { ISR_NONE = 0, ISR_RX, ISR_TX, TRANSMIT_DELAY_COMPLETED };
 

src/platform/portduino/architecture.h

@@ -2,15 +2,18 @@
 
 #define ARCH_PORTDUINO
 
-//
-// defaults for NRF52 architecture
-//
-
 //
 // set HW_VENDOR
 //
 
 #define HW_VENDOR meshtastic_HardwareModel_PORTDUINO
 
-#define HAS_RTC 1
+#ifndef HAS_WIFI
 #define HAS_WIFI 1
+#endif
+#ifndef HAS_RTC
+#define HAS_RTC 1
+#endif
+#ifndef HAS_TELEMETRY
+#define HAS_TELEMETRY 1
+#endif

src/sleep.cpp

@@ -298,9 +298,18 @@ esp_sleep_wakeup_cause_t doLightSleep(uint64_t sleepMsec) // FIXME, use a more r
     if (pmu_found)
         gpio_wakeup_enable((gpio_num_t)PMU_IRQ, GPIO_INTR_LOW_LEVEL); // pmu irq
 #endif
-    assert(esp_sleep_enable_gpio_wakeup() == ESP_OK);
-    assert(esp_sleep_enable_timer_wakeup(sleepUsec) == ESP_OK);
-    assert(esp_light_sleep_start() == ESP_OK);
+    auto res = esp_sleep_enable_gpio_wakeup();
+    if (res != ESP_OK)
+        LOG_DEBUG("esp_sleep_enable_gpio_wakeup result %d\n", res);
+    assert(res == ESP_OK);
+    res = esp_sleep_enable_timer_wakeup(sleepUsec);
+    if (res != ESP_OK)
+        LOG_DEBUG("esp_sleep_enable_timer_wakeup result %d\n", res);
+    assert(res == ESP_OK);
+    res = esp_light_sleep_start();
+    if (res != ESP_OK)
+        LOG_DEBUG("esp_light_sleep_start result %d\n", res);
+    assert(res == ESP_OK);
 
     esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
 #ifdef BUTTON_PIN

suppressions.txt

@@ -43,3 +43,4 @@ postfixOperator:*/mqtt/*
 missingOverride
 virtualCallInConstructor
 
+passedByValue:*/RedirectablePrint.h

variants/Dongle_nRF52840-pca10059-v1/platformio.ini

@@ -1,6 +1,7 @@
 [env:pca10059_diy_eink]
 extends = nrf52840_base
 board = nordic_pca10059
+board_level = extra
 build_flags = ${nrf52840_base.build_flags} -Ivariants/Dongle_nRF52840-pca10059-v1 -D NORDIC_PCA10059
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/Dongle_nRF52840-pca10059-v1>
 lib_deps = 

variants/betafpv_2400_tx_micro/platformio.ini

@@ -1,6 +1,7 @@
 [env:betafpv_2400_tx_micro]
 extends = esp32_base
 board = esp32doit-devkit-v1
+board_level = extra
 build_flags =
   ${esp32_base.build_flags}
   -D BETAFPV_2400_TX

variants/betafpv_900_tx_nano/platformio.ini

@@ -0,0 +1,16 @@
+[env:betafpv_900_tx_nano]
+extends = esp32_base
+board = esp32doit-devkit-v1
+build_flags =
+  ${esp32_base.build_flags}
+  -D BETAFPV_900_TX_NANO
+  -D VTABLES_IN_FLASH=1
+  -D CONFIG_DISABLE_HAL_LOCKS=1
+  -O2
+  -I variants/betafpv_900_tx_nano
+board_build.f_cpu = 240000000L
+upload_protocol = esptool
+upload_port = /dev/ttyUSB0
+upload_speed = 460800
+lib_deps =
+  ${esp32_base.lib_deps}

variants/betafpv_900_tx_nano/variant.h

@@ -0,0 +1,28 @@
+// https://betafpv.com/products/elrs-nano-tx-module
+
+// no screen
+#define HAS_SCREEN 0
+
+// NO GPS
+#undef GPS_RX_PIN
+#undef GPS_TX_PIN
+
+#define USE_RF95
+
+#define RF95_SCK 18
+#define RF95_MISO 19
+#define RF95_MOSI 23
+#define RF95_NSS 5
+
+#define LORA_DIO0 4
+#define LORA_RESET 14
+#define LORA_DIO1 2
+#define LORA_DIO2
+#define LORA_DIO3
+
+#define LED_PIN 16 // green - blue is at 17
+
+#define BUTTON_PIN 25
+#define BUTTON_NEED_PULLUP
+
+#undef EXT_NOTIFY_OUT

variants/diy/platformio.ini

@@ -2,6 +2,7 @@
 [env:meshtastic-diy-v1]
 extends = esp32_base
 board = esp32doit-devkit-v1
+board_level = extra
 build_flags =
   ${esp32_base.build_flags}
   -D DIY_V1
@@ -13,6 +14,7 @@ build_flags =
 [env:meshtastic-diy-v1.1]
 extends = esp32_base
 board = esp32doit-devkit-v1
+board_level = extra
 build_flags =
   ${esp32_base.build_flags}
   -D DIY_V1
@@ -24,6 +26,7 @@ build_flags =
 [env:meshtastic-dr-dev]
 extends = esp32_base
 board = esp32doit-devkit-v1
+board_level = extra
 board_upload.maximum_size = 4194304
 board_upload.maximum_ram_size = 532480
 build_flags =

variants/feather_diy/platformio.ini

@@ -2,6 +2,7 @@
 [env:feather_diy]
 extends = nrf52840_base
 board = adafruit_feather_nrf52840
+board_level = extra
 build_flags = ${nrf52840_base.build_flags} -Ivariants/feather_diy -Dfeather_diy
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/feather_diy>
 lib_deps = 

variants/genieblocks/platformio.ini

@@ -1,7 +0,0 @@
-; The GenieBlocks LORA prototype board
-; note: @geeksville disabled because genieblocks_lora is not checked into the boards directory, please send in a PR to add it ;-)
-;[env:genieblocks_lora]
-;extends = esp32_base
-;board = genieblocks_lora
-;build_flags = 
-;  ${esp32_base.build_flags} -D GENIEBLOCKS -Ivariants/genieblocks

variants/genieblocks/variant.h

@@ -1,26 +0,0 @@
-#undef GPS_RX_PIN
-#undef GPS_TX_PIN
-#define GPS_RX_PIN 5
-#define GPS_TX_PIN 18
-#define GPS_RESET_N 10
-#define GPS_EXTINT 23 // On MAX-M8 module pin name is EXTINT. On L70 module pin name is STANDBY.
-
-#define BATTERY_PIN 39    // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define BATTERY_EN_PIN 14 // Voltage voltage divider enable pin connected to mosfet
-
-#define I2C_SDA 4 // I2C pins for this board
-#define I2C_SCL 2
-
-#define LED_PIN 12 // If defined we will blink this LED
-//#define BUTTON_PIN 36  // If defined, this will be used for user button presses (ToDo problem on that line on debug screen -->
-// Long press start!) #define BUTTON_NEED_PULLUP //GPIOs 34 to 39 are GPIs – input only pins. These pins don’t have internal
-// pull-ups or pull-down resistors.
-
-#define USE_RF95
-#define LORA_DIO0 38 // a No connect on the SX1262 module
-#define LORA_RESET 9
-
-#define RF95_SCK 22
-#define RF95_MISO 19
-#define RF95_MOSI 13
-#define RF95_NSS 21

variants/heltec_v1/platformio.ini

@@ -1,6 +1,7 @@
 [env:heltec-v1]
 ;build_type = debug ; to make it possible to step through our jtag debugger 
 extends = esp32_base
+board_level = extra
 board = heltec_wifi_lora_32
 build_flags = 
   ${esp32_base.build_flags} -D HELTEC_V1 -I variants/heltec_v1

variants/heltec_v1/variant.h

@@ -20,8 +20,8 @@
 #ifndef USE_JTAG
 #define LORA_RESET 14
 #endif
-#define LORA_DIO1 35 // Not really used
-#define LORA_DIO2 34 // Not really used
+#define LORA_DIO1 RADIOLIB_NC
+#define LORA_DIO2 32 // Not really used
 
 // ratio of voltage divider = 3.20 (R1=100k, R2=220k)
 #define ADC_MULTIPLIER 3.2

variants/heltec_v2.1/platformio.ini

@@ -2,5 +2,6 @@
 ;build_type = debug ; to make it possible to step through our jtag debugger 
 extends = esp32_base
 board = heltec_wifi_lora_32_V2
+board_level = extra
 build_flags = 
   ${esp32_base.build_flags} -D HELTEC_V2_1 -I variants/heltec_v2.1

variants/heltec_v2.1/variant.h

@@ -24,7 +24,7 @@
 #ifndef USE_JTAG
 #define LORA_RESET 14
 #endif
-#define LORA_DIO1 35 // Not really used
+#define LORA_DIO1 35 // https://www.thethingsnetwork.org/forum/t/big-esp32-sx127x-topic-part-3/18436
 #define LORA_DIO2 34 // Not really used
 
 #define ADC_MULTIPLIER 3.8

variants/heltec_v2/platformio.ini

@@ -2,5 +2,6 @@
 ;build_type = debug ; to make it possible to step through our jtag debugger 
 extends = esp32_base
 board = heltec_wifi_lora_32_V2
+board_level = extra
 build_flags = 
   ${esp32_base.build_flags} -D HELTEC_V2_0 -I variants/heltec_v2