More meshtastik-like behavior

Can decode default channel (primary channel) with default password.

Revamped serial output.

.vscode/extensions.json

@@ -4,5 +4,7 @@
     "recommendations": [
         "platformio.platformio-ide"
     ],
-    "unwantedRecommendations": [  ]
+    "unwantedRecommendations": [
+        "ms-vscode.cpptools-extension-pack"
+    ]
 }

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.associations": {
+        "iostream": "cpp"
+    }
+}

platformio.ini

@@ -15,7 +15,15 @@ default_envs = cubecell_board
 framework = arduino
 monitor_speed = 115200
 build_flags = -Os
-lib_deps = 	jgromes/RadioLib
+  -Isrc -Isrc/mesh -Isrc/mesh/generated
+	-D PB_ENABLE_MALLOC=1
+	-D APP_VERSION=0.01.1
+lib_deps = 	nanopb/Nanopb
+			https://github.com/meshtastic/protobufs.git
+			jgromes/RadioLib
+      https://github.com/kokke/tiny-AES-c.git
+
+
 check_tool = cppcheck
 build_type = release
 
@@ -24,6 +32,7 @@ extends = common
 platform  = heltec-cubecell
 board = cubecell_board
 platform_packages = platformio/toolchain-gccarmnoneeabi@^1.120301.0
-build_flags = ${common.build_flags}
+build_flags = ${common.build_flags} -Isrc/platform/cubecell
   -D CUBECELL=1
+  -D HW_VENDOR=CUBECELL
 

src/MeshTypes.h

@@ -0,0 +1,53 @@
+#pragma once
+
+// low level types
+
+//#include "MemoryPool.h"
+#include "mesh-pb-constants.h"
+//#include <Arduino.h>
+
+typedef uint32_t NodeNum;
+typedef uint32_t PacketId; // A packet sequence number
+
+#define NODENUM_BROADCAST UINT32_MAX
+#define ERRNO_OK 0
+#define ERRNO_NO_INTERFACES 33
+#define ERRNO_UNKNOWN 32  // pick something that doesn't conflict with RH_ROUTER_ERROR_UNABLE_TO_DELIVER
+#define ERRNO_DISABLED 34 // the interface is disabled
+
+/*
+ * Source of a received message
+ */
+enum RxSource {
+    RX_SRC_LOCAL, // message was generated locally
+    RX_SRC_RADIO, // message was received from radio mesh
+    RX_SRC_USER   // message was received from end-user device
+};
+
+/**
+ * the max number of hops a message can pass through, used as the default max for hop_limit in MeshPacket.
+ *
+ * We reserve 3 bits in the header so this could be up to 7, but given the high range of lora and typical usecases, keeping
+ * maxhops to 3 should be fine for a while.  This also serves to prevent routing/flooding attempts to be attempted for
+ * too long.
+ **/
+#define HOP_MAX 7
+
+/// We normally just use max 3 hops for sending reliable messages
+#define HOP_RELIABLE 3
+
+typedef int ErrorCode;
+
+/// Alloc and free packets to our global, ISR safe pool
+//extern Allocator<meshtastic_MeshPacket> &packetPool;
+
+/**
+ * Most (but not always) of the time we want to treat packets 'from' the local phone (where from == 0), as if they originated on
+ * the local node. If from is zero this function returns our node number instead
+ */
+NodeNum getFrom(const meshtastic_MeshPacket *p);
+
+NodeNum getFrom(const meshtastic_MeshPacket *p)
+{
+    return (p->from == 0) ? 0 : p->from;
+}

src/configuration.h

@@ -0,0 +1,212 @@
+/*
+
+TTGO T-BEAM Tracker for The Things Network
+
+Copyright (C) 2018 by Xose Pérez <xose dot perez at gmail dot com>
+
+This code requires LMIC library by Matthijs Kooijman
+https://github.com/matthijskooijman/arduino-lmic
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#pragma once
+
+#include <Arduino.h>
+
+#ifdef RV3028_RTC
+#include "Melopero_RV3028.h"
+#endif
+#ifdef PCF8563_RTC
+#include "pcf8563.h"
+#endif
+
+// -----------------------------------------------------------------------------
+// Version
+// -----------------------------------------------------------------------------
+
+// If app version is not specified we assume we are not being invoked by the build script
+#ifndef APP_VERSION
+#error APP_VERSION must be set by the build environment
+#endif
+
+// FIXME: This is still needed by the Bluetooth Stack and needs to be replaced by something better. Remnant of the old versioning
+// system.
+#ifndef HW_VERSION
+#define HW_VERSION "1.0"
+#endif
+
+// -----------------------------------------------------------------------------
+// Configuration
+// -----------------------------------------------------------------------------
+
+// If we are using the JTAG port for debugging, some pins must be left free for that (and things like GPS have to be disabled)
+// we don't support jtag on the ttgo - access to gpio 12 is a PITA
+#define REQUIRE_RADIO true // If true, we will fail to start if the radio is not found
+
+/// Convert a preprocessor name into a quoted string
+#define xstr(s) ystr(s)
+#define ystr(s) #s
+
+/// Convert a preprocessor name into a quoted string and if that string is empty use "unset"
+#define optstr(s) (xstr(s)[0] ? xstr(s) : "unset")
+
+// Nop definition for these attributes that are specific to ESP32
+#ifndef EXT_RAM_ATTR
+#define EXT_RAM_ATTR
+#endif
+#ifndef IRAM_ATTR
+#define IRAM_ATTR
+#endif
+#ifndef RTC_DATA_ATTR
+#define RTC_DATA_ATTR
+#endif
+
+// -----------------------------------------------------------------------------
+// Feature toggles
+// -----------------------------------------------------------------------------
+
+// Disable use of the NTP library and related features
+// #define DISABLE_NTP
+
+// Disable the welcome screen and allow
+// #define DISABLE_WELCOME_UNSET
+
+// -----------------------------------------------------------------------------
+// OLED & Input
+// -----------------------------------------------------------------------------
+
+#define SSD1306_ADDRESS 0x3C
+#define ST7567_ADDRESS 0x3F
+
+// The SH1106 controller is almost, but not quite, the same as SSD1306
+// Define this if you know you have that controller or your "SSD1306" misbehaves.
+// #define USE_SH1106
+
+// Define if screen should be mirrored left to right
+// #define SCREEN_MIRROR
+
+// I2C Keyboards (M5Stack, RAK14004, T-Deck)
+#define CARDKB_ADDR 0x5F
+#define TDECK_KB_ADDR 0x55
+#define BBQ10_KB_ADDR 0x1F
+
+// -----------------------------------------------------------------------------
+// SENSOR
+// -----------------------------------------------------------------------------
+#define BME_ADDR 0x76
+#define BME_ADDR_ALTERNATE 0x77
+#define MCP9808_ADDR 0x18
+#define INA_ADDR 0x40
+#define INA_ADDR_ALTERNATE 0x41
+#define INA3221_ADDR 0x42
+#define QMC6310_ADDR 0x1C
+#define QMI8658_ADDR 0x6B
+#define QMC5883L_ADDR 0x1E
+#define SHTC3_ADDR 0x70
+#define LPS22HB_ADDR 0x5C
+#define LPS22HB_ADDR_ALT 0x5D
+#define SHT31_ADDR 0x44
+#define PMSA0031_ADDR 0x12
+
+// -----------------------------------------------------------------------------
+// ACCELEROMETER
+// -----------------------------------------------------------------------------
+#define MPU6050_ADDR 0x68
+#define LIS3DH_ADR 0x18
+#define BMA423_ADDR 0x19
+
+// -----------------------------------------------------------------------------
+// LED
+// -----------------------------------------------------------------------------
+#define NCP5623_ADDR 0x38
+
+// -----------------------------------------------------------------------------
+// Security
+// -----------------------------------------------------------------------------
+
+#define ATECC608B_ADDR 0x35
+
+// -----------------------------------------------------------------------------
+// GPS
+// -----------------------------------------------------------------------------
+
+#define GPS_BAUDRATE 9600
+
+#ifndef GPS_THREAD_INTERVAL
+#define GPS_THREAD_INTERVAL 200
+#endif
+
+// convert 24-bit color to 16-bit (56K)
+#define COLOR565(r, g, b) (((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3))
+
+/* Step #1: offer chance for variant-specific defines */
+//#include "variant.h"
+
+/* Step #2: follow with defines common to the architecture;
+   also enable HAS_ option not specifically disabled by variant.h */
+//#include "architecture.h"
+
+/* Step #3: mop up with disabled values for HAS_ options not handled by the above two */
+
+#ifndef HAS_WIFI
+#define HAS_WIFI 0
+#endif
+#ifndef HAS_ETHERNET
+#define HAS_ETHERNET 0
+#endif
+#ifndef HAS_SCREEN
+#define HAS_SCREEN 0
+#endif
+#ifndef HAS_WIRE
+#define HAS_WIRE 0
+#endif
+#ifndef HAS_GPS
+#define HAS_GPS 0
+#endif
+#ifndef HAS_BUTTON
+#define HAS_BUTTON 0
+#endif
+#ifndef HAS_TRACKBALL
+#define HAS_TRACKBALL 0
+#endif
+#ifndef HAS_TOUCHSCREEN
+#define HAS_TOUCHSCREEN 0
+#endif
+#ifndef HAS_TELEMETRY
+#define HAS_TELEMETRY 0
+#endif
+#ifndef HAS_SENSOR
+#define HAS_SENSOR 0
+#endif
+#ifndef HAS_RADIO
+#define HAS_RADIO 0
+#endif
+#ifndef HAS_RTC
+#define HAS_RTC 0
+#endif
+#ifndef HAS_CPU_SHUTDOWN
+#define HAS_CPU_SHUTDOWN 0
+#endif
+#ifndef HAS_BLUETOOTH
+#define HAS_BLUETOOTH 0
+#endif
+
+//#include "DebugConfiguration.h"
+//#include "RF95Configuration.h"
+
+#ifndef HW_VENDOR
+#error HW_VENDOR must be defined
+#endif

src/main.cpp

@@ -1,4 +1,5 @@
 #include <main.h>
+#include <assert.h>
 
 typedef struct {
     uint32_t to, from, id;
@@ -8,9 +9,20 @@ typedef struct {
 } PacketHeader;
 
 void setup() {
-#ifndef SILENT
+  UART_1_RxWakeDisableInt(); // no wake on UART activity
+  memset(idList, 0, MAX_ID_LIST *4);
+  for (uint8_t i = 0; i<(MAX_TX_QUEUE - 1); i++) {
+    txQueue[i].size = 0;
+  }
+  #ifndef SILENT
   Serial.begin(115200);
-#endif
+  #endif
+
+  MSG("[INFO][CryptoEngine] Initializing ... ");
+  memcpy(psk.bytes, mypsk, sizeof(mypsk));
+  psk.length = sizeof(psk.bytes);
+  crypto->setKey(psk);
+
   initRegion();       // create regions[] and load myRegion
   applyModemConfig(); // apply lora settings
   MSG("[INFO][SX1262] Starting to listen ... ");
@@ -28,41 +40,55 @@ void loop() {
     PacketReceived = false;
     const size_t length = radio.getPacketLength();
     state = radio.readData(radiobuf, length);
-    MSG("[RX]");
+    PacketHeader* h = (PacketHeader *)radiobuf;
+
+    //MSG("[RX]");
     if (state == RADIOLIB_ERR_NONE) {
       const int32_t payloadLen = length - sizeof(PacketHeader);
       if (payloadLen < 0) {
-        MSG("\n[WARN]Not a Meshtastic packet, too short!\n");
+        MSG("[WARN]Not a Meshtastic packet, too short!\n");
         return; // will not repeat
       }
-
-      PacketHeader *h = (PacketHeader *)radiobuf;
-
       const uint8_t hop_limit = h->flags & PACKET_FLAGS_HOP_MASK;
-      
+      /*
       MSG(" (id=0x%08X) HopLim=%i from=0x%08X to=0x%08X WantAck=%s viaMQTT=%s", h->id, 
          hop_limit, h->from, h->to, (h->flags & PACKET_FLAGS_WANT_ACK_MASK)? "YES":"NO", (h->flags & PACKET_FLAGS_VIA_MQTT_MASK)? "YES":"NO");
       
       MSGFLOAT(" SNR=",radio.getSNR() );
       MSGFLOAT(" RSSI=", radio.getRSSI() );
-      MSG(" re-send=%s\n", ( (lastPacketID != h->id) && (hop_limit!=0) )?"YES":"NO");
+      */
+      repeatPacket =  update_idList(h->id); 
+      if ( hop_limit == 0) repeatPacket = false; // do not repeat if id is known or hop limit is Zero
+#ifndef SILENT // print packet:
+      const uint8_t *payload = radiobuf + sizeof(PacketHeader);
+      mp.from = h->from;
+      mp.to = h->to;
+      mp.id = h->id;
+      mp.channel = h->channel;
+      mp.hop_limit = h->flags   & PACKET_FLAGS_HOP_MASK;
+      mp.want_ack = h->flags & PACKET_FLAGS_WANT_ACK_MASK;
+      mp.via_mqtt = h->flags & PACKET_FLAGS_VIA_MQTT_MASK;
+      mp.rx_snr = radio.getSNR();
+      mp.rx_rssi = lround(radio.getRSSI());
+      mp.which_payload_variant = meshtastic_MeshPacket_encrypted_tag; // Mark that the payload is still encrypted at this point
+      assert(((uint32_t)payloadLen) <= sizeof(mp.encrypted.bytes));
+      memcpy(mp.encrypted.bytes, payload, payloadLen);
+      mp.encrypted.size = payloadLen;
+      MSG("\n[NEW]");
+      if ( !repeatPacket ){
+        MSG("(id=0x%08X) no repeat! (HopLim %d)\n", mp.id, mp.hop_limit);
+      } else {
+        perhapsDecode(&mp); // try to decode and print the result
+      }
+#endif //SILENT     
       
-      if ( (lastPacketID != h->id) && (hop_limit!=0) ) {
+/*    MSG(" repeat=%s\n", (repeatPacket)?"YES":"NO");
+      MSGFLOAT(" Freq Error=", radio.getFrequencyError());
+      MSG("\n");
+*/
+      if ( repeatPacket ) {
         h->flags -= 1; // decrease HopLim by 1
-        clearInterrupts();
+        enqueueTX(radiobuf, length);
-        while ( radio.scanChannel() == RADIOLIB_LORA_DETECTED ) delay(100);
-        MSG("[TX] (id=0x%08X) HopLim=%i ... ", h->id, (h->flags & PACKET_FLAGS_HOP_MASK));
-        lastPacketID = h->id;
-        clearInterrupts();
-        radio.setPacketSentAction(ISR_setPacketSent);
-        state=radio.startTransmit((uint8_t*)&radiobuf, length);
-        if (state == RADIOLIB_ERR_NONE) {
-          MSG("OK\n");
-        }
-        else {
-          MSG("failed, ERR = %i - resume RX", state);
-          PacketSent=true;
-        }
       }
       
     } else if (state == RADIOLIB_ERR_CRC_MISMATCH) {
@@ -72,6 +98,31 @@ void loop() {
     }
   }
 
+  if (txQueueHasPacket) { // try to repeat packets
+    //const long wait = lround( abs( radio.getSNR() * radio.getRSSI() ));
+    long wait = 1000;
+    radio.startChannelScan(3, 24, 10);
+    for (int i = 1; i < wait; i++) {
+      if (radio.getChannelScanResult() == RADIOLIB_LORA_DETECTED) {
+        clearInterrupts();
+        radio.setPacketReceivedAction(ISR_setReceived);
+        radio.startReceive(20000); 
+        return; // new packet arrived while waiting!
+      }
+      delay(2);
+    }
+
+    uint8_t idx = poptxQueue();
+    if (txQueue[idx].size == 0){
+      txQueueHasPacket = false; // empty Queue, do nothing
+      //MSG("[INFO] TX Queue is empty\n");
+    }
+    else {
+      perhapsSend(&txQueue[idx].buf[0], txQueue[idx].size);
+      txQueue[idx].size = 0;
+    }    
+  }
+
   if (PacketSent) {
     PacketSent = false;
     startReceive();
@@ -107,3 +158,316 @@ void startReceive(){
   radio.setPacketReceivedAction(ISR_setReceived);
   state=radio.startReceive(); 
 }
+
+bool update_idList(uint32_t id){
+  for (uint8_t i=0; i < (MAX_ID_LIST - 1); i++) {
+     //MSG("\nstored: 0x%08X  delivered: 0x%08X",idQueue[i-1], id);
+    if (idList[i] == id){
+     return false; // packet ID is known, no Queue update
+    }
+  }
+
+  // store new ID:
+  uint8_t idx = MAX_ID_LIST;
+  for (uint8_t i=0; i < (MAX_ID_LIST -1); i++){
+    if (idList[i] == 0) {
+      idx = i;
+      break;
+    } 
+  }
+  if (idx == MAX_ID_LIST) {
+    idList[0] = id;
+    idList[1] = 0;
+  }
+  else {
+    idList[idx] = id;
+    if (++idx < MAX_ID_LIST) { idList[idx] = 0; }
+    else { idList[0] = 0; }
+  }
+  return true; // packet ID was not known, Queue was updated
+}
+
+void enqueueTX(uint8_t* buf, size_t size){
+  PacketHeader* h = (PacketHeader *)buf;
+  uint8_t idx = MAX_TX_QUEUE;
+  for (uint8_t i=0; i<(MAX_TX_QUEUE -1); i++) {
+    if (txQueue[i].size == 0) {  // search for a free slot
+      idx = i;
+      break;
+    }
+  }
+  if (idx == MAX_TX_QUEUE) {  // no free slot, overwrite oldest packet
+    idx = 0;
+    for (uint8_t i=1; i<(MAX_TX_QUEUE -1); i++) {
+      if (txQueue[idx].packetTime < txQueue[i].packetTime) idx = i;
+    }
+  }
+  txQueue[idx].size = size;
+  MSG("[INF](id=0x%08X) enQueue Index=%i size=%i", h->id, idx, size);
+  txQueue[idx].packetTime = (uint32_t)RtcGetTimerValue();
+  MSG(" Time=%i\n",txQueue[idx].packetTime); //MSG("\n");
+  memcpy(&txQueue[idx].buf[0], buf, size);
+  //MSG(" Copy done!\n");
+  txQueueHasPacket = true;
+}
+
+uint8_t poptxQueue(void) {
+  uint8_t idx = MAX_TX_QUEUE;
+  for (uint8_t i=0 ;i < (MAX_TX_QUEUE -1); i++ ){
+    if (txQueue[i].size != 0) {
+      idx = i;
+      break;
+    }
+  }
+  if (idx == MAX_TX_QUEUE) { // empty Queue
+    return 0; 
+  }
+  for (uint8_t i=idx; i<(MAX_TX_QUEUE -1); i++) {
+    if ( (txQueue[i].size != 0) && (txQueue[idx].packetTime < txQueue[i].packetTime) ) idx = i; // find oldest packet
+  }
+  //MSG("[INFO]POP index=%i\n", idx);
+  return idx;
+}
+
+void perhapsSend(uint8_t* buf, size_t size) {
+  PacketHeader* h = (PacketHeader *)buf;
+  //clearInterrupts();
+  //while ( radio.scanChannel() == RADIOLIB_LORA_DETECTED ) delay( (uint32_t)lround( abs(radio.getSNR() + radio.getRSSI() ) ) );
+  MSG("[TX] (id=0x%08X) HopLim=%i ... ", h->id, (h->flags & PACKET_FLAGS_HOP_MASK));
+  clearInterrupts();
+  radio.setPacketSentAction(ISR_setPacketSent);
+  state=radio.startTransmit(buf, size);
+  if (state == RADIOLIB_ERR_NONE) {
+    MSG("OK\n");
+  }
+  else {
+    MSG("failed, ERR = %i - resume RX", state);
+    PacketSent=true; // do not halt on error
+  }
+  
+}
+
+static uint8_t bytes[MAX_RHPACKETLEN];
+
+bool perhapsDecode(meshtastic_MeshPacket *p)
+{
+/*  concurrency::LockGuard g(cryptLock);
+
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER &&
+        config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_ALL_SKIP_DECODING)
+        return false;
+
+    if (config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_KNOWN_ONLY &&
+        !nodeDB.getMeshNode(p->from)->has_user) {
+        LOG_DEBUG("Node 0x%x not in NodeDB. Rebroadcast mode KNOWN_ONLY will ignore packet\n", p->from);
+        return false;
+    }
+*/
+    if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag)
+        return true; // If packet was already decoded just return
+
+    // assert(p->which_payloadVariant == MeshPacket_encrypted_tag);
+
+    // Try to find a channel that works with this hash
+/*    for (ChannelIndex chIndex = 0; chIndex < channels.getNumChannels(); chIndex++) {
+        // Try to use this hash/channel pair
+        if (channels.decryptForHash(chIndex, p->channel)) { */
+            // Try to decrypt the packet if we can
+            size_t rawSize = p->encrypted.size;
+            assert(rawSize <= sizeof(bytes));
+            memcpy(bytes, p->encrypted.bytes,
+                   rawSize); // we have to copy into a scratch buffer, because these bytes are a union with the decoded protobuf
+            crypto->decrypt(p->from, p->id, rawSize, bytes);
+
+            // printBytes("plaintext", bytes, p->encrypted.size);
+
+            // Take those raw bytes and convert them back into a well structured protobuf we can understand
+            memset(&p->decoded, 0, sizeof(p->decoded));
+            if (!pb_decode_from_bytes(bytes, rawSize, &meshtastic_Data_msg, &p->decoded)) {
+                MSG("[ERROR]Invalid protobufs in received mesh packet (bad psk?)!\n");
+            } else if (p->decoded.portnum == meshtastic_PortNum_UNKNOWN_APP) {
+                MSG("[ERROR]Invalid portnum (bad psk?)!\n");
+            } else {
+                // parsing was successful
+                p->which_payload_variant = meshtastic_MeshPacket_decoded_tag; // change type to decoded
+                p->channel = generateHash(0);                                         // change to store the index instead of the hash
+
+                // Decompress if needed. jm
+                if (p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_COMPRESSED_APP) {
+                    // Decompress the payload
+                    char compressed_in[meshtastic_Constants_DATA_PAYLOAD_LEN] = {};
+                    char decompressed_out[meshtastic_Constants_DATA_PAYLOAD_LEN] = {};
+                    int decompressed_len;
+
+                    memcpy(compressed_in, p->decoded.payload.bytes, p->decoded.payload.size);
+
+                    decompressed_len = unishox2_decompress_simple(compressed_in, p->decoded.payload.size, decompressed_out);
+
+                    // LOG_DEBUG("\n\n**\n\nDecompressed length - %d \n", decompressed_len);
+
+                    memcpy(p->decoded.payload.bytes, decompressed_out, decompressed_len);
+
+                    // Switch the port from PortNum_TEXT_MESSAGE_COMPRESSED_APP to PortNum_TEXT_MESSAGE_APP
+                    p->decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP;
+                }
+
+                printPacket("", p);
+                return true;
+            }
+        //}
+    //}
+
+    MSG("[ERROR]No suitable channel found for decoding, hash was 0x%x!\n", p->channel);
+    return false;
+}
+
+void printPacket(const char *prefix, const meshtastic_MeshPacket *p) {
+
+  MSG("%s(id=0x%08X fr=0x%.2X to=0x%.2X, WantAck=%s, HopLim=%d Ch=0x%X", prefix, p->id,
+                                            p->from, p->to, (p->want_ack)? "YES":"NO", p->hop_limit, p->channel);
+  if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
+        auto &s = p->decoded;
+        MSG(" Portnum=%d", s.portnum);
+        if (s.want_response)
+            MSG(" WANTRESP");
+        if (s.source != 0)
+            MSG(" source=%08x", s.source);
+        if (s.dest != 0)
+            MSG(" dest=%08x", s.dest);
+        if (s.request_id)
+            MSG(" requestId=%0x", s.request_id);
+        if (p->rx_time != 0)
+        MSG(" rxtime=%u", p->rx_time);
+        if (p->rx_snr != 0.0)
+            MSGFLOAT(" rxSNR=", p->rx_snr);
+        if (p->rx_rssi != 0)
+            MSG(" rxRSSI=%i", p->rx_rssi);
+        if (p->via_mqtt != 0)
+            MSG(" via MQTT");
+        if (p->priority != 0)
+            MSG(" priority=%d", p->priority);
+
+        MSG("\nPayload: "); printVariants(p); 
+    } else {
+        MSG(" encrypted!\n");
+    }
+    //MSG("\n");    
+}
+
+void printVariants(const meshtastic_MeshPacket *p){
+
+  // Make sure we have a decoded packet
+  if (p->which_payload_variant !=  meshtastic_MeshPacket_decoded_tag) 
+    return;
+
+  auto &mp = p->decoded;
+
+  // TEXT MESSAGE
+  // /modules/TextMessageModule.cpp
+  if (mp.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP){
+    MSG("\"%.*s\"\n", mp.payload.size, mp.payload.bytes);
+    return;
+  }
+
+  // POSITION MESSAGE
+  // /modules/PositionModule.cpp
+  if (mp.portnum == meshtastic_PortNum_POSITION_APP){
+    MSG("Position ");
+    meshtastic_Position pos;
+    if (!pb_decode_from_bytes(mp.payload.bytes, mp.payload.size, &meshtastic_Position_msg, &pos)) {
+      MSG("*** Error ***\n");
+      return;
+    }
+    // Log packet size and data fields
+    MSG("node=%08x l=%d latI=%d lonI=%d msl=%d hae=%d geo=%d pdop=%d hdop=%d vdop=%d siv=%d fxq=%d fxt=%d pts=%d "
+             "time=%d\n",
+             p->from, mp.payload.size, pos.latitude_i, pos.longitude_i, pos.altitude, pos.altitude_hae,
+             pos.altitude_geoidal_separation, pos.PDOP, pos.HDOP, pos.VDOP, pos.sats_in_view, pos.fix_quality, pos.fix_type, pos.timestamp,
+             pos.time);
+    return;
+  }
+  
+  // NODEINFO MESSAGE
+  // /modules/NodeInfoModule.cpp
+  if (mp.portnum == meshtastic_PortNum_NODEINFO_APP){
+    MSG("Node Info: ");
+    meshtastic_User user;
+    if (!pb_decode_from_bytes(mp.payload.bytes, mp.payload.size, &meshtastic_User_msg, &user)) {
+      MSG("*** Error ***\n");
+      return;
+    }
+    MSG("id:%s short: %s long: %s licensed: %s ",user.id, user.short_name, user.long_name, (user.is_licensed)?"YES":"NO");
+    MSG("MAC:");
+    for (uint8_t i=0; i<sizeof(user.macaddr); i++) { 
+      MSG("%0X",user.macaddr[i]);
+    }
+    MSG(" HW model: %i role: %i\n", (uint8_t)user.hw_model, (uint8_t)user.role);
+    return;
+  }
+    
+  
+
+  // TELEMETRY
+  if (mp.portnum == meshtastic_PortNum_TELEMETRY_APP){
+    MSG("Telemetry ");
+    meshtastic_Telemetry telemetry;
+    meshtastic_Telemetry *t = &telemetry;
+    if (!pb_decode_from_bytes(mp.payload.bytes, mp.payload.size, &meshtastic_Telemetry_msg, &telemetry)) {
+      MSG("*** Error ***\n");
+      return;
+    }
+    // /modules/Telemetry/PowerTelemetry.cpp
+    if (t->which_variant == meshtastic_Telemetry_power_metrics_tag) {
+        MSG("(Power Metrics): ");
+        MSGFLOAT(  "ch1_voltage=", t->variant.power_metrics.ch1_voltage);
+        MSGFLOAT(", ch1_current=", t->variant.power_metrics.ch1_current);
+        MSGFLOAT(", ch2_voltage=", t->variant.power_metrics.ch2_voltage);
+        MSGFLOAT(", ch2_current=", t->variant.power_metrics.ch2_current);
+        MSGFLOAT(", ch3_voltage=", t->variant.power_metrics.ch3_voltage);
+        MSGFLOAT(", ch3_current=", t->variant.power_metrics.ch3_current);
+        MSG("\n" ); 
+        return;
+    }
+    // /modules/Telemetry/DeviceTelemetry.cpp
+    if (t->which_variant == meshtastic_Telemetry_device_metrics_tag) {
+        MSG("(Device Metrics): ");
+        MSGFLOAT(  "air_util_tx=",         t->variant.device_metrics.air_util_tx);
+        MSGFLOAT(", channel_utilization=", t->variant.device_metrics.channel_utilization);
+        MSGFLOAT(", battery_level=",       t->variant.device_metrics.battery_level);
+        MSGFLOAT(", voltage=",             t->variant.device_metrics.voltage);
+        MSG("\n" );
+        return;
+    }
+    // /modules/Telemetry/EnvironmentTelemetry.cpp
+    if (t->which_variant == meshtastic_Telemetry_environment_metrics_tag) {
+        MSG("(Environment Metrics): ");
+        MSGFLOAT("barometric_pressure=", t->variant.environment_metrics.barometric_pressure);
+        MSGFLOAT(", current=",   t->variant.environment_metrics.current);
+        MSGFLOAT(", gas_resistance=",t->variant.environment_metrics.gas_resistance);
+        MSGFLOAT(", relative_humidity=",t->variant.environment_metrics.relative_humidity);
+        MSGFLOAT(", temperature=", t->variant.environment_metrics.temperature);
+        MSGFLOAT(", voltage=", t->variant.environment_metrics.voltage);
+        MSG("\n");
+        return;
+    }
+    // /modules/Telemetry/AirQualityTelemetry.cpp
+    if (t->which_variant == meshtastic_Telemetry_air_quality_metrics_tag) {
+        MSG("Air Quality Metrics:\n");
+        MSG( "pm10_standard=%i, pm25_standard=%i, pm100_standard=%i\n", 
+                 t->variant.air_quality_metrics.pm10_standard, t->variant.air_quality_metrics.pm25_standard,
+                 t->variant.air_quality_metrics.pm100_standard);
+        MSG("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);
+        return;
+    }
+  }
+
+  // No known PortNum:
+  MSG("\"");
+  for (uint32_t i=0; i < mp.payload.size; i++){
+    MSG("%X", mp.payload.bytes[i]);
+  }
+  MSG("\"\n");
+  return;
+}

src/main.h

@@ -1,5 +1,4 @@
 #include <Arduino.h>
-#include <RadioLib.h>
 
 // #define SILENT           // turn off serial output
 
@@ -16,19 +15,63 @@
 
 #define CC_MAX_POWER        22      // TX power setting. Maximum for CubeCell is 22, enforced by RadioLib.
 
+#define MAX_ID_LIST 32 // number of stored packet IDs to prevent unnecesary repeating
+#define MAX_TX_QUEUE 16 // max number of packets which can be waiting for transmission
+#define MAX_RHPACKETLEN 256
+
+#include <RadioLib.h>
 #ifdef CUBECELL
 #include "cyPm.c"  // for reliable sleep we use MCU_deepSleep()
     extern  uint32_t systime;   // CubeCell global system time count, Millis
     SX1262 radio = new Module(RADIOLIB_BUILTIN_MODULE);
 #endif //CUBECELL
 
-uint8_t radiobuf[256];
+/// 16 bytes of random PSK for our _public_ default channel that all devices power up on (AES128)
-uint32_t lastPacketID = 0;
+/// Meshtastic default key (AQ==):
+static const uint8_t mypsk[] = {0xd4, 0xf1, 0xbb, 0x3a, 0x20, 0x29, 0x07, 0x59,
+                                0xf0, 0xbc, 0xff, 0xab, 0xcf, 0x4e, 0x69, 0x01};
+// No Crypto = all zero
+
+#include <assert.h>
+#include <pb.h>
+#include <MeshTypes.h>
+#include <pb_decode.h>
+#include <pb_encode.h>
+#include <CryptoEngine.h>
+
+extern "C"
+{ 
+#include <mesh/compression/unishox2.h>
+}
+
+CryptoKey psk;
+meshtastic_MeshPacket mp;
+
+uint8_t radiobuf[MAX_RHPACKETLEN -1];
+
+typedef struct {
+    size_t   size;
+    uint8_t  buf[MAX_RHPACKETLEN -1];
+    uint32_t packetTime;
+} Packet_t;
+
+Packet_t txQueue[MAX_TX_QUEUE - 1];
+uint32_t idList[MAX_ID_LIST - 1];
+bool repeatPacket = false;
+bool txQueueHasPacket = false;
 int state = RADIOLIB_ERR_NONE;
 
 void MCU_deepsleep(void);   
 void clearInterrupts(void);
 void startReceive(void);
+bool update_idList(uint32_t id);
+void enqueueTX(uint8_t* buf, size_t size);
+uint8_t poptxQueue(void);
+void perhapsSend(uint8_t* buf, size_t size);
+
+void printVariants(const meshtastic_MeshPacket *p);
+void printPacket(const char *prefix, const meshtastic_MeshPacket *p);
+bool perhapsDecode(meshtastic_MeshPacket *p);
 
 // Flag and ISR for "Received packet" - events
 volatile bool PacketReceived = false;
@@ -56,72 +99,36 @@ void ISR_setPacketSent(void) {
 /**************
  * Meshtastic * 
  **************/
+
 #define PACKET_FLAGS_HOP_MASK 0x07
 #define PACKET_FLAGS_WANT_ACK_MASK 0x08
 #define PACKET_FLAGS_VIA_MQTT_MASK 0x10
 
-typedef enum _meshtastic_Config_LoRaConfig_RegionCode {
+/// helper function for encoding a record as a protobuf, any failures to encode are fatal and we will panic
-    /* Region is not set */
+/// returns the encoded packet size
-    meshtastic_Config_LoRaConfig_RegionCode_UNSET = 0,
+size_t pb_encode_to_bytes(uint8_t *destbuf, size_t destbufsize, const pb_msgdesc_t *fields, const void *src_struct)
-    /* United States */
+{
-    meshtastic_Config_LoRaConfig_RegionCode_US = 1,
+    pb_ostream_t stream = pb_ostream_from_buffer(destbuf, destbufsize);
-    /* European Union 433mhz */
+    if (!pb_encode(&stream, fields, src_struct)) {
-    meshtastic_Config_LoRaConfig_RegionCode_EU_433 = 2,
+        MSG("[ERROR]Panic: can't encode protobuf reason='%s'\n", PB_GET_ERROR(&stream));
-    /* European Union 868mhz */
+        assert(
-    meshtastic_Config_LoRaConfig_RegionCode_EU_868 = 3,
+            0); // If this assert fails it probably means you made a field too large for the max limits specified in mesh.options
-    /* China */
+    } else {
-    meshtastic_Config_LoRaConfig_RegionCode_CN = 4,
+        return stream.bytes_written;
-    /* Japan */
+    }
-    meshtastic_Config_LoRaConfig_RegionCode_JP = 5,
+}
-    /* Australia / New Zealand */
-    meshtastic_Config_LoRaConfig_RegionCode_ANZ = 6,
-    /* Korea */
-    meshtastic_Config_LoRaConfig_RegionCode_KR = 7,
-    /* Taiwan */
-    meshtastic_Config_LoRaConfig_RegionCode_TW = 8,
-    /* Russia */
-    meshtastic_Config_LoRaConfig_RegionCode_RU = 9,
-    /* India */
-    meshtastic_Config_LoRaConfig_RegionCode_IN = 10,
-    /* New Zealand 865mhz */
-    meshtastic_Config_LoRaConfig_RegionCode_NZ_865 = 11,
-    /* Thailand */
-    meshtastic_Config_LoRaConfig_RegionCode_TH = 12,
-    /* WLAN Band */
-    meshtastic_Config_LoRaConfig_RegionCode_LORA_24 = 13,
-    /* Ukraine 433mhz */
-    meshtastic_Config_LoRaConfig_RegionCode_UA_433 = 14,
-    /* Ukraine 868mhz */
-    meshtastic_Config_LoRaConfig_RegionCode_UA_868 = 15,
-    /* Malaysia 433mhz */
-    meshtastic_Config_LoRaConfig_RegionCode_MY_433 = 16,
-    /* Malaysia 919mhz */
-    meshtastic_Config_LoRaConfig_RegionCode_MY_919 = 17,
-    /* Singapore 923mhz */
-    meshtastic_Config_LoRaConfig_RegionCode_SG_923 = 18
-} meshtastic_Config_LoRaConfig_RegionCode;
-
-/* Standard predefined channel settings
- Note: these mappings must match ModemPreset Choice in the device code. */
-typedef enum _meshtastic_Config_LoRaConfig_ModemPreset {
-    /* Long Range - Fast */
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST = 0,
-    /* Long Range - Slow */
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW = 1,
-    /* Very Long Range - Slow */
-    meshtastic_Config_LoRaConfig_ModemPreset_VERY_LONG_SLOW = 2,
-    /* Medium Range - Slow */
-    meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW = 3,
-    /* Medium Range - Fast */
-    meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST = 4,
-    /* Short Range - Slow */
-    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW = 5,
-    /* Short Range - Fast */
-    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST = 6,
-    /* Long Range - Moderately Fast */
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE = 7
-} meshtastic_Config_LoRaConfig_ModemPreset;
 
+/// helper function for decoding a record as a protobuf, we will return false if the decoding failed
+bool pb_decode_from_bytes(const uint8_t *srcbuf, size_t srcbufsize, const pb_msgdesc_t *fields, void *dest_struct)
+{
+    pb_istream_t stream = pb_istream_from_buffer(srcbuf, srcbufsize);
+    if (!pb_decode(&stream, fields, dest_struct)) {
+        MSG("[ERROR]Can't decode protobuf reason='%s', pb_msgdesc %p\n", PB_GET_ERROR(&stream), fields);
+        return false;
+    } else {
+        return true;
+    }
+}
 
 #define RDEF(name, freq_start, freq_end, duty_cycle, spacing, power_limit, audio_permitted, frequency_switching, wide_lora)      \
     {                                                                                                                            \
@@ -284,6 +291,43 @@ uint32_t hash(const char *str)
     return hash;
 }
 
+/** A channel number (index into the channel table)
+ */
+typedef uint8_t ChannelIndex;
+
+/** A low quality hash of the channel PSK and the channel name.  created by generateHash(chIndex)
+ * Used as a hint to limit which PSKs are considered for packet decoding.
+ */
+typedef uint8_t ChannelHash;
+
+uint8_t xorHash(const uint8_t *p, size_t len)
+{
+    uint8_t code = 0;
+    for (size_t i = 0; i < len; i++)
+        code ^= p[i];
+    return code;
+}
+
+/** Given a channel number, return the (0 to 255) hash for that channel.
+ * The hash is just an xor of the channel name followed by the channel PSK being used for encryption
+ * If no suitable channel could be found, return -1
+ */
+
+int16_t generateHash(ChannelIndex channelNum)
+{
+    auto k = psk; //getKey(channelNum);
+    if (k.length < 0)
+        return -1; // invalid
+    else {
+        const char *name = CC_CHANNEL_NAME; //getName(channelNum);
+        uint8_t h = xorHash((const uint8_t *)name, strlen(name));
+
+        h ^= xorHash(k.bytes, k.length);
+
+        return h;
+    }
+}
+
 void applyModemConfig()
 {
     float bw=0;

src/mesh-pb-constants.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "meshtastic/admin.pb.h"
+#include "meshtastic/deviceonly.pb.h"
+#include "meshtastic/localonly.pb.h"
+#include "meshtastic/mesh.pb.h"
+
+// this file defines constants which come from mesh.options
+
+// Tricky macro to let you find the sizeof a type member
+#define member_size(type, member) sizeof(((type *)0)->member)
+
+/// max number of packets which can be waiting for delivery to android - note, this value comes from mesh.options protobuf
+// FIXME - max_count is actually 32 but we save/load this as one long string of preencoded MeshPacket bytes - not a big array in
+// RAM #define MAX_RX_TOPHONE (member_size(DeviceState, receive_queue) / member_size(DeviceState, receive_queue[0]))
+#define MAX_RX_TOPHONE 32
+
+/// max number of nodes allowed in the mesh
+#define MAX_NUM_NODES (member_size(meshtastic_DeviceState, node_db_lite) / member_size(meshtastic_DeviceState, node_db_lite[0]))
+
+/// Max number of channels allowed
+#define MAX_NUM_CHANNELS (member_size(meshtastic_ChannelFile, channels) / member_size(meshtastic_ChannelFile, channels[0]))
+
+/// helper function for encoding a record as a protobuf, any failures to encode are fatal and we will panic
+/// returns the encoded packet size
+size_t pb_encode_to_bytes(uint8_t *destbuf, size_t destbufsize, const pb_msgdesc_t *fields, const void *src_struct);
+
+/// helper function for decoding a record as a protobuf, we will return false if the decoding failed
+bool pb_decode_from_bytes(const uint8_t *srcbuf, size_t srcbufsize, const pb_msgdesc_t *fields, void *dest_struct);
+
+/// Read from an Arduino File
+bool readcb(pb_istream_t *stream, uint8_t *buf, size_t count);
+
+/// Write to an arduino file
+bool writecb(pb_ostream_t *stream, const uint8_t *buf, size_t count);
+
+/** is_in_repeated is a macro/function that returns true if a specified word appears in a repeated protobuf array.
+ * It relies on the following naming conventions from nanopb:
+ *
+ * pb_size_t ignore_incoming_count;
+ * uint32_t ignore_incoming[3];
+ */
+bool is_in_helper(uint32_t n, const uint32_t *array, pb_size_t count);
+
+#define is_in_repeated(name, n) is_in_helper(n, name, name##_count)

src/mesh/CryptoEngine.cpp

@@ -0,0 +1,42 @@
+#include "CryptoEngine.h"
+#include "configuration.h"
+
+//concurrency::Lock *cryptLock;
+#ifndef SILENT
+    #define MSG(...) Serial.printf(__VA_ARGS__)
+#else
+    #define MSG(...)
+#endif
+
+void CryptoEngine::setKey(const CryptoKey &k)
+{
+    MSG("Using AES%d key!\n", k.length * 8);
+    key = k;
+}
+
+/**
+ * Encrypt a packet
+ *
+ * @param bytes is updated in place
+ */
+void CryptoEngine::encrypt(uint32_t fromNode, uint64_t packetId, size_t numBytes, uint8_t *bytes)
+{
+    MSG("noop encryption!\n");
+}
+
+void CryptoEngine::decrypt(uint32_t fromNode, uint64_t packetId, size_t numBytes, uint8_t *bytes)
+{
+    MSG("noop decryption!\n");
+}
+
+/**
+ * Init our 128 bit nonce for a new packet
+ */
+void CryptoEngine::initNonce(uint32_t fromNode, uint64_t packetId)
+{
+    memset(nonce, 0, sizeof(nonce));
+
+    // use memcpy to avoid breaking strict-aliasing
+    memcpy(nonce, &packetId, sizeof(uint64_t));
+    memcpy(nonce + sizeof(uint64_t), &fromNode, sizeof(uint32_t));
+}

src/mesh/CryptoEngine.h

@@ -0,0 +1,64 @@
+#pragma once
+
+//#include "concurrency/LockGuard.h"
+#include <Arduino.h>
+
+//extern concurrency::Lock *cryptLock;
+
+struct CryptoKey {
+    uint8_t bytes[32];
+
+    /// # of bytes, or -1 to mean "invalid key - do not use"
+    int8_t length;
+};
+
+/**
+ * see docs/software/crypto.md for details.
+ *
+ */
+
+#define MAX_BLOCKSIZE 256
+
+class CryptoEngine
+{
+  protected:
+    /** Our per packet nonce */
+    uint8_t nonce[16] = {0};
+
+    CryptoKey key = {};
+
+  public:
+    virtual ~CryptoEngine() {}
+
+    /**
+     * Set the key used for encrypt, decrypt.
+     *
+     * As a special case: If all bytes are zero, we assume _no encryption_ and send all data in cleartext.
+     *
+     * @param numBytes must be 16 (AES128), 32 (AES256) or 0 (no crypt)
+     * @param bytes a _static_ buffer that will remain valid for the life of this crypto instance (i.e. this class will cache the
+     * provided pointer)
+     */
+    virtual void setKey(const CryptoKey &k);
+
+    /**
+     * Encrypt a packet
+     *
+     * @param bytes is updated in place
+     */
+    virtual void encrypt(uint32_t fromNode, uint64_t packetId, size_t numBytes, uint8_t *bytes);
+    virtual void decrypt(uint32_t fromNode, uint64_t packetId, size_t numBytes, uint8_t *bytes);
+
+  protected:
+    /**
+     * Init our 128 bit nonce for a new packet
+     *
+     * The NONCE is constructed by concatenating (from MSB to LSB):
+     * a 64 bit packet number (stored in little endian order)
+     * a 32 bit sending node number (stored in little endian order)
+     * a 32 bit block counter (starts at zero)
+     */
+    void initNonce(uint32_t fromNode, uint64_t packetId);
+};
+
+extern CryptoEngine *crypto;

src/mesh/compression/unishox2.h

@@ -0,0 +1,389 @@
+/*
+ * Copyright (C) 2020 Siara Logics (cc)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Arundale Ramanathan
+ *
+ */
+
+/**
+ * @file unishox2.h
+ * @author Arundale Ramanathan, James Z. M. Gao
+ * @brief API for Unishox2 Compression and Decompression
+ *
+ * This file describes each function of the Unishox2 API \n
+ * For finding out how this API can be used in your program, \n
+ * please see test_unishox2.c.
+ */
+
+#ifndef unishox2
+#define unishox2
+
+#define UNISHOX_VERSION "2.0" ///< Unicode spec version
+
+/**
+ * Macro switch to enable/disable output buffer length parameter in low level api \n
+ * Disabled by default \n
+ * When this macro is defined, the all the API functions \n
+ * except the simple API functions accept an additional parameter olen \n
+ * that enables the developer to pass the size of the output buffer provided \n
+ * so that the api function may not write beyond that length. \n
+ * This can be disabled if the developer knows that the buffer provided is sufficient enough \n
+ * so no additional parameter is passed and the program is faster since additional check \n
+ * for output length is not performed at each step \n
+ * The simple api, i.e. unishox2_(de)compress_simple will always omit the buffer length
+ */
+#ifndef UNISHOX_API_WITH_OUTPUT_LEN
+#define UNISHOX_API_WITH_OUTPUT_LEN 0
+#endif
+
+/// Upto 8 bits of initial magic bit sequence can be included. Bit count can be specified with UNISHOX_MAGIC_BIT_LEN
+#ifndef UNISHOX_MAGIC_BITS
+#define UNISHOX_MAGIC_BITS 0xFF
+#endif
+
+/// Desired length of Magic bits defined by UNISHOX_MAGIC_BITS
+#ifdef UNISHOX_MAGIC_BIT_LEN
+#if UNISHOX_MAGIC_BIT_LEN < 0 || 9 <= UNISHOX_MAGIC_BIT_LEN
+#error "UNISHOX_MAGIC_BIT_LEN need between [0, 8)"
+#endif
+#else
+#define UNISHOX_MAGIC_BIT_LEN 1
+#endif
+
+// enum {USX_ALPHA = 0, USX_SYM, USX_NUM, USX_DICT, USX_DELTA};
+
+/// Default Horizontal codes. When composition of text is know beforehand, the other hcodes in this section can be used to achieve
+/// more compression.
+#define USX_HCODES_DFLT                                                                                                          \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        0x00, 0x40, 0x80, 0xC0, 0xE0                                                                                             \
+    }
+/// Length of each default hcode
+#define USX_HCODE_LENS_DFLT                                                                                                      \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        2, 2, 2, 3, 3                                                                                                            \
+    }
+
+/// Horizontal codes preset for English Alphabet content only
+#define USX_HCODES_ALPHA_ONLY                                                                                                    \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        0x00, 0x00, 0x00, 0x00, 0x00                                                                                             \
+    }
+/// Length of each Alpha only hcode
+#define USX_HCODE_LENS_ALPHA_ONLY                                                                                                \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        0, 0, 0, 0, 0                                                                                                            \
+    }
+
+/// Horizontal codes preset for Alpha Numeric content only
+#define USX_HCODES_ALPHA_NUM_ONLY                                                                                                \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        0x00, 0x00, 0x80, 0x00, 0x00                                                                                             \
+    }
+/// Length of each Alpha numeric hcode
+#define USX_HCODE_LENS_ALPHA_NUM_ONLY                                                                                            \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        1, 0, 1, 0, 0                                                                                                            \
+    }
+
+/// Horizontal codes preset for Alpha Numeric and Symbol content only
+#define USX_HCODES_ALPHA_NUM_SYM_ONLY                                                                                            \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        0x00, 0x80, 0xC0, 0x00, 0x00                                                                                             \
+    }
+/// Length of each Alpha numeric and symbol hcodes
+#define USX_HCODE_LENS_ALPHA_NUM_SYM_ONLY                                                                                        \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        1, 2, 2, 0, 0                                                                                                            \
+    }
+
+/// Horizontal codes preset favouring Alphabet content
+#define USX_HCODES_FAVOR_ALPHA                                                                                                   \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        0x00, 0x80, 0xA0, 0xC0, 0xE0                                                                                             \
+    }
+/// Length of each hcode favouring Alpha content
+#define USX_HCODE_LENS_FAVOR_ALPHA                                                                                               \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        1, 3, 3, 3, 3                                                                                                            \
+    }
+
+/// Horizontal codes preset favouring repeating sequences
+#define USX_HCODES_FAVOR_DICT                                                                                                    \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        0x00, 0x40, 0xC0, 0x80, 0xE0                                                                                             \
+    }
+/// Length of each hcode favouring repeating sequences
+#define USX_HCODE_LENS_FAVOR_DICT                                                                                                \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        2, 2, 3, 2, 3                                                                                                            \
+    }
+
+/// Horizontal codes preset favouring symbols
+#define USX_HCODES_FAVOR_SYM                                                                                                     \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        0x80, 0x00, 0xA0, 0xC0, 0xE0                                                                                             \
+    }
+/// Length of each hcode favouring symbols
+#define USX_HCODE_LENS_FAVOR_SYM                                                                                                 \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        3, 1, 3, 3, 3                                                                                                            \
+    }
+
+//#define USX_HCODES_FAVOR_UMLAUT {0x00, 0x40, 0xE0, 0xC0, 0x80}
+//#define USX_HCODE_LENS_FAVOR_UMLAUT {2, 2, 3, 3, 2}
+
+/// Horizontal codes preset favouring umlaut letters
+#define USX_HCODES_FAVOR_UMLAUT                                                                                                  \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        0x80, 0xA0, 0xC0, 0xE0, 0x00                                                                                             \
+    }
+/// Length of each hcode favouring umlaut letters
+#define USX_HCODE_LENS_FAVOR_UMLAUT                                                                                              \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        3, 3, 3, 3, 1                                                                                                            \
+    }
+
+/// Horizontal codes preset for no repeating sequences
+#define USX_HCODES_NO_DICT                                                                                                       \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        0x00, 0x40, 0x80, 0x00, 0xC0                                                                                             \
+    }
+/// Length of each hcode for no repeating sequences
+#define USX_HCODE_LENS_NO_DICT                                                                                                   \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        2, 2, 2, 0, 2                                                                                                            \
+    }
+
+/// Horizontal codes preset for no Unicode characters
+#define USX_HCODES_NO_UNI                                                                                                        \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        0x00, 0x40, 0x80, 0xC0, 0x00                                                                                             \
+    }
+/// Length of each hcode for no Unicode characters
+#define USX_HCODE_LENS_NO_UNI                                                                                                    \
+    (const unsigned char[])                                                                                                      \
+    {                                                                                                                            \
+        2, 2, 2, 2, 0                                                                                                            \
+    }
+
+/// Default frequently occurring sequences. When composition of text is know beforehand, the other sequences in this section can
+/// be used to achieve more compression.
+#define USX_FREQ_SEQ_DFLT                                                                                                        \
+    (const char *[])                                                                                                             \
+    {                                                                                                                            \
+        "\": \"", "\": ", "</", "=\"", "\":\"", "://"                                                                            \
+    }
+/// Frequently occurring sequences in text content
+#define USX_FREQ_SEQ_TXT                                                                                                         \
+    (const char *[])                                                                                                             \
+    {                                                                                                                            \
+        " the ", " and ", "tion", " with", "ing", "ment"                                                                         \
+    }
+/// Frequently occurring sequences in URL content
+#define USX_FREQ_SEQ_URL                                                                                                         \
+    (const char *[])                                                                                                             \
+    {                                                                                                                            \
+        "https://", "www.", ".com", "http://", ".org", ".net"                                                                    \
+    }
+/// Frequently occurring sequences in JSON content
+#define USX_FREQ_SEQ_JSON                                                                                                        \
+    (const char *[])                                                                                                             \
+    {                                                                                                                            \
+        "\": \"", "\": ", "\",", "}}}", "\":\"", "}}"                                                                            \
+    }
+/// Frequently occurring sequences in HTML content
+#define USX_FREQ_SEQ_HTML                                                                                                        \
+    (const char *[])                                                                                                             \
+    {                                                                                                                            \
+        "</", "=\"", "div", "href", "class", "<p>"                                                                               \
+    }
+/// Frequently occurring sequences in XML content
+#define USX_FREQ_SEQ_XML                                                                                                         \
+    (const char *[])                                                                                                             \
+    {                                                                                                                            \
+        "</", "=\"", "\">", "<?xml version=\"1.0\"", "xmlns:", "://"                                                             \
+    }
+
+/// Commonly occurring templates (ISO Date/Time, ISO Date, US Phone number, ISO Time, Unused)
+#define USX_TEMPLATES                                                                                                            \
+    (const char *[])                                                                                                             \
+    {                                                                                                                            \
+        "tfff-of-tfTtf:rf:rf.fffZ", "tfff-of-tf", "(fff) fff-ffff", "tf:rf:rf", 0                                                \
+    }
+
+/// Default preset parameter set. When composition of text is know beforehand, the other parameter sets in this section can be
+/// used to achieve more compression.
+#define USX_PSET_DFLT USX_HCODES_DFLT, USX_HCODE_LENS_DFLT, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
+/// Preset parameter set for English Alphabet only content
+#define USX_PSET_ALPHA_ONLY USX_HCODES_ALPHA_ONLY, USX_HCODE_LENS_ALPHA_ONLY, USX_FREQ_SEQ_TXT, USX_TEMPLATES
+/// Preset parameter set for Alpha numeric content
+#define USX_PSET_ALPHA_NUM_ONLY USX_HCODES_ALPHA_NUM_ONLY, USX_HCODE_LENS_ALPHA_NUM_ONLY, USX_FREQ_SEQ_TXT, USX_TEMPLATES
+/// Preset parameter set for Alpha numeric and symbol content
+#define USX_PSET_ALPHA_NUM_SYM_ONLY                                                                                              \
+    USX_HCODES_ALPHA_NUM_SYM_ONLY, USX_HCODE_LENS_ALPHA_NUM_SYM_ONLY, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
+/// Preset parameter set for Alpha numeric symbol content having predominantly text
+#define USX_PSET_ALPHA_NUM_SYM_ONLY_TXT                                                                                          \
+    USX_HCODES_ALPHA_NUM_SYM_ONLY, USX_HCODE_LENS_ALPHA_NUM_SYM_ONLY, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
+/// Preset parameter set favouring Alphabet content
+#define USX_PSET_FAVOR_ALPHA USX_HCODES_FAVOR_ALPHA, USX_HCODE_LENS_FAVOR_ALPHA, USX_FREQ_SEQ_TXT, USX_TEMPLATES
+/// Preset parameter set favouring repeating sequences
+#define USX_PSET_FAVOR_DICT USX_HCODES_FAVOR_DICT, USX_HCODE_LENS_FAVOR_DICT, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
+/// Preset parameter set favouring symbols
+#define USX_PSET_FAVOR_SYM USX_HCODES_FAVOR_SYM, USX_HCODE_LENS_FAVOR_SYM, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
+/// Preset parameter set favouring unlaut letters
+#define USX_PSET_FAVOR_UMLAUT USX_HCODES_FAVOR_UMLAUT, USX_HCODE_LENS_FAVOR_UMLAUT, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
+/// Preset parameter set for when there are no repeating sequences
+#define USX_PSET_NO_DICT USX_HCODES_NO_DICT, USX_HCODE_LENS_NO_DICT, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
+/// Preset parameter set for when there are no unicode symbols
+#define USX_PSET_NO_UNI USX_HCODES_NO_UNI, USX_HCODE_LENS_NO_UNI, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
+/// Preset parameter set for when there are no unicode symbols favouring text
+#define USX_PSET_NO_UNI_FAVOR_TEXT USX_HCODES_NO_UNI, USX_HCODE_LENS_NO_UNI, USX_FREQ_SEQ_TXT, USX_TEMPLATES
+/// Preset parameter set favouring URL content
+#define USX_PSET_URL USX_HCODES_DFLT, USX_HCODE_LENS_DFLT, USX_FREQ_SEQ_URL, USX_TEMPLATES
+/// Preset parameter set favouring JSON content
+#define USX_PSET_JSON USX_HCODES_DFLT, USX_HCODE_LENS_DFLT, USX_FREQ_SEQ_JSON, USX_TEMPLATES
+/// Preset parameter set favouring JSON content having no Unicode symbols
+#define USX_PSET_JSON_NO_UNI USX_HCODES_NO_UNI, USX_HCODE_LENS_NO_UNI, USX_FREQ_SEQ_JSON, USX_TEMPLATES
+/// Preset parameter set favouring XML content
+#define USX_PSET_XML USX_HCODES_DFLT, USX_HCODE_LENS_DFLT, USX_FREQ_SEQ_XML, USX_TEMPLATES
+/// Preset parameter set favouring HTML content
+#define USX_PSET_HTML USX_HCODES_DFLT, USX_HCODE_LENS_DFLT, USX_FREQ_SEQ_HTML, USX_TEMPLATES
+
+/**
+ * This structure is used when a string array needs to be compressed.
+ * This is passed as a parameter to the unishox2_decompress_lines() function
+ */
+struct us_lnk_lst {
+    char *data;
+    struct us_lnk_lst *previous;
+};
+
+/**
+ * This macro is for internal use, but builds upon the macro UNISHOX_API_WITH_OUTPUT_LEN
+ * When the macro UNISHOX_API_WITH_OUTPUT_LEN is defined, the all the API functions
+ * except the simple API functions accept an additional parameter olen
+ * that enables the developer to pass the size of the output buffer provided
+ * so that the api function may not write beyond that length.
+ * This can be disabled if the developer knows that the buffer provided is sufficient enough
+ * so no additional parameter is passed and the program is faster since additional check
+ * for output length is not performed at each step
+ */
+#if defined(UNISHOX_API_WITH_OUTPUT_LEN) && UNISHOX_API_WITH_OUTPUT_LEN != 0
+#define UNISHOX_API_OUT_AND_LEN(out, olen) out, olen
+#else
+#define UNISHOX_API_OUT_AND_LEN(out, olen) out
+#endif
+
+/**
+ * Simple API for compressing a string
+ * @param[in] in    Input ASCII / UTF-8 string
+ * @param[in] len   length in bytes
+ * @param[out] out  output buffer - should be large enough to hold compressed output
+ */
+extern int unishox2_compress_simple(const char *in, int len, char *out);
+/**
+ * Simple API for decompressing a string
+ * @param[in] in    Input compressed bytes (output of unishox2_compress functions)
+ * @param[in] len   length of 'in' in bytes
+ * @param[out] out  output buffer for ASCII / UTF-8 string - should be large enough
+ */
+extern int unishox2_decompress_simple(const char *in, int len, char *out);
+/**
+ * Comprehensive API for compressing a string
+ *
+ * Presets are available for the last four parameters so they can be passed as single parameter. \n
+ * See USX_PSET_* macros. Example call: \n
+ *    unishox2_compress(in, len, out, olen, USX_PSET_ALPHA_ONLY);
+ *
+ * @param[in] in             Input ASCII / UTF-8 string
+ * @param[in] len            length in bytes
+ * @param[out] out           output buffer - should be large enough to hold compressed output
+ * @param[in] olen           length of 'out' buffer in bytes. Can be omitted if sufficient buffer is provided
+ * @param[in] usx_hcodes     Horizontal codes (array of bytes). See macro section for samples.
+ * @param[in] usx_hcode_lens Length of each element in usx_hcodes array
+ * @param[in] usx_freq_seq   Frequently occurring sequences. See USX_FREQ_SEQ_* macros for samples
+ * @param[in] usx_templates  Templates of frequently occurring patterns. See USX_TEMPLATES macro.
+ */
+extern int unishox2_compress(const char *in, int len, UNISHOX_API_OUT_AND_LEN(char *out, int olen),
+                             const unsigned char usx_hcodes[], const unsigned char usx_hcode_lens[], const char *usx_freq_seq[],
+                             const char *usx_templates[]);
+/**
+ * Comprehensive API for de-compressing a string
+ *
+ * Presets are available for the last four parameters so they can be passed as single parameter. \n
+ * See USX_PSET_* macros. Example call: \n
+ *    unishox2_decompress(in, len, out, olen, USX_PSET_ALPHA_ONLY);
+ *
+ * @param[in] in             Input compressed bytes (output of unishox2_compress functions)
+ * @param[in] len            length of 'in' in bytes
+ * @param[out] out           output buffer - should be large enough to hold de-compressed output
+ * @param[in] olen           length of 'out' buffer in bytes. Can be omitted if sufficient buffer is provided
+ * @param[in] usx_hcodes     Horizontal codes (array of bytes). See macro section for samples.
+ * @param[in] usx_hcode_lens Length of each element in usx_hcodes array
+ * @param[in] usx_freq_seq   Frequently occurring sequences. See USX_FREQ_SEQ_* macros for samples
+ * @param[in] usx_templates  Templates of frequently occurring patterns. See USX_TEMPLATES macro.
+ */
+extern int unishox2_decompress(const char *in, int len, UNISHOX_API_OUT_AND_LEN(char *out, int olen),
+                               const unsigned char usx_hcodes[], const unsigned char usx_hcode_lens[], const char *usx_freq_seq[],
+                               const char *usx_templates[]);
+/**
+ * More Comprehensive API for compressing array of strings
+ *
+ * See unishox2_compress() function for parameter definitions. \n
+ * This function takes an additional parameter, i.e. 'prev_lines' - the usx_lnk_lst structure \n
+ * See -g parameter in test_unishox2.c to find out how this can be used. \n
+ * This function is used when an array of strings need to be compressed \n
+ * and stored in a compressed array of bytes for use as a constant in other programs \n
+ * where each element of the array can be decompressed and used at runtime.
+ */
+extern int unishox2_compress_lines(const char *in, int len, UNISHOX_API_OUT_AND_LEN(char *out, int olen),
+                                   const unsigned char usx_hcodes[], const unsigned char usx_hcode_lens[],
+                                   const char *usx_freq_seq[], const char *usx_templates[], struct us_lnk_lst *prev_lines);
+/**
+ * More Comprehensive API for de-compressing array of strings \n
+ * This function is not be used in conjunction with unishox2_compress_lines()
+ *
+ * See unishox2_decompress() function for parameter definitions. \n
+ * Typically an array is compressed using unishox2_compress_lines() and \n
+ * a header (.h) file is generated using the resultant compressed array. \n
+ * This header file can be used in another program with another decompress \n
+ * routine which takes this compressed array as parameter and index to be \n
+ * decompressed.
+ */
+extern int unishox2_decompress_lines(const char *in, int len, UNISHOX_API_OUT_AND_LEN(char *out, int olen),
+                                     const unsigned char usx_hcodes[], const unsigned char usx_hcode_lens[],
+                                     const char *usx_freq_seq[], const char *usx_templates[], struct us_lnk_lst *prev_lines);
+
+#endif

src/mesh/generated/.clang-format

@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false

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

@@ -0,0 +1,20 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#include "meshtastic/admin.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_AdminMessage, meshtastic_AdminMessage, 2)
+
+
+PB_BIND(meshtastic_HamParameters, meshtastic_HamParameters, AUTO)
+
+
+PB_BIND(meshtastic_NodeRemoteHardwarePinsResponse, meshtastic_NodeRemoteHardwarePinsResponse, 2)
+
+
+
+
+

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

@@ -0,0 +1,352 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_ADMIN_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_ADMIN_PB_H_INCLUDED
+#include <pb.h>
+#include "meshtastic/channel.pb.h"
+#include "meshtastic/config.pb.h"
+#include "meshtastic/connection_status.pb.h"
+#include "meshtastic/mesh.pb.h"
+#include "meshtastic/module_config.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+/* TODO: REPLACE */
+typedef enum _meshtastic_AdminMessage_ConfigType {
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ConfigType_DEVICE_CONFIG = 0,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ConfigType_POSITION_CONFIG = 1,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ConfigType_POWER_CONFIG = 2,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ConfigType_NETWORK_CONFIG = 3,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ConfigType_DISPLAY_CONFIG = 4,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ConfigType_LORA_CONFIG = 5,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ConfigType_BLUETOOTH_CONFIG = 6
+} meshtastic_AdminMessage_ConfigType;
+
+/* TODO: REPLACE */
+typedef enum _meshtastic_AdminMessage_ModuleConfigType {
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_MQTT_CONFIG = 0,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_SERIAL_CONFIG = 1,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_EXTNOTIF_CONFIG = 2,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_STOREFORWARD_CONFIG = 3,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_RANGETEST_CONFIG = 4,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_TELEMETRY_CONFIG = 5,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_CANNEDMSG_CONFIG = 6,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_AUDIO_CONFIG = 7,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_REMOTEHARDWARE_CONFIG = 8,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_NEIGHBORINFO_CONFIG = 9,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_AMBIENTLIGHTING_CONFIG = 10,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_DETECTIONSENSOR_CONFIG = 11,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_PAXCOUNTER_CONFIG = 12
+} 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;
+
+/* Response envelope for node_remote_hardware_pins */
+typedef struct _meshtastic_NodeRemoteHardwarePinsResponse {
+    /* Nodes and their respective remote hardware GPIO pins */
+    pb_size_t node_remote_hardware_pins_count;
+    meshtastic_NodeRemoteHardwarePin node_remote_hardware_pins[16];
+} meshtastic_NodeRemoteHardwarePinsResponse;
+
+/* 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) */
+typedef struct _meshtastic_AdminMessage {
+    pb_size_t which_payload_variant;
+    union {
+        /* Send the specified channel in the response to this message
+     NOTE: This field is sent with the channel index + 1 (to ensure we never try to send 'zero' - which protobufs treats as not present) */
+        uint32_t get_channel_request;
+        /* TODO: REPLACE */
+        meshtastic_Channel get_channel_response;
+        /* Send the current owner data in the response to this message. */
+        bool get_owner_request;
+        /* TODO: REPLACE */
+        meshtastic_User get_owner_response;
+        /* Ask for the following config data to be sent */
+        meshtastic_AdminMessage_ConfigType get_config_request;
+        /* Send the current Config in the response to this message. */
+        meshtastic_Config get_config_response;
+        /* Ask for the following config data to be sent */
+        meshtastic_AdminMessage_ModuleConfigType get_module_config_request;
+        /* Send the current Config in the response to this message. */
+        meshtastic_ModuleConfig get_module_config_response;
+        /* Get the Canned Message Module messages in the response to this message. */
+        bool get_canned_message_module_messages_request;
+        /* Get the Canned Message Module messages in the response to this message. */
+        char get_canned_message_module_messages_response[201];
+        /* Request the node to send device metadata (firmware, protobuf version, etc) */
+        bool get_device_metadata_request;
+        /* Device metadata response */
+        meshtastic_DeviceMetadata get_device_metadata_response;
+        /* Get the Ringtone in the response to this message. */
+        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;
+        /* Get the mesh's nodes with their available gpio pins for RemoteHardware module use */
+        bool get_node_remote_hardware_pins_request;
+        /* Respond with the mesh's nodes with their available gpio pins for RemoteHardware module use */
+        meshtastic_NodeRemoteHardwarePinsResponse get_node_remote_hardware_pins_response;
+        /* Enter (UF2) DFU mode
+     Only implemented on NRF52 currently */
+        bool enter_dfu_mode_request;
+        /* Delete the file by the specified path from the device */
+        char delete_file_request[201];
+        /* Set the owner for this node */
+        meshtastic_User set_owner;
+        /* Set channels (using the new API).
+     A special channel is the "primary channel".
+     The other records are secondary channels.
+     Note: only one channel can be marked as primary.
+     If the client sets a particular channel to be primary, the previous channel will be set to SECONDARY automatically. */
+        meshtastic_Channel set_channel;
+        /* Set the current Config */
+        meshtastic_Config set_config;
+        /* Set the current Config */
+        meshtastic_ModuleConfig set_module_config;
+        /* Set the Canned Message Module messages text. */
+        char set_canned_message_module_messages[201];
+        /* Set the ringtone for ExternalNotification. */
+        char set_ringtone_message[231];
+        /* Remove the node by the specified node-num from the NodeDB on the device */
+        uint32_t remove_by_nodenum;
+        /* Set specified node-num to be favorited on the NodeDB on the device */
+        uint32_t set_favorite_node;
+        /* Set specified node-num to be un-favorited on the NodeDB on the device */
+        uint32_t remove_favorite_node;
+        /* Set fixed position data on the node and then set the position.fixed_position = true */
+        meshtastic_Position set_fixed_position;
+        /* Clear fixed position coordinates and then set position.fixed_position = false */
+        bool remove_fixed_position;
+        /* Begins an edit transaction for config, module config, owner, and channel settings changes
+     This will delay the standard *implicit* save to the file system and subsequent reboot behavior until committed (commit_edit_settings) */
+        bool begin_edit_settings;
+        /* Commits an open transaction for any edits made to config, module config, owner, and channel settings */
+        bool commit_edit_settings;
+        /* Tell the node to reboot into the OTA Firmware in this many seconds (or <0 to cancel reboot)
+     Only Implemented for ESP32 Devices. This needs to be issued to send a new main firmware via bluetooth. */
+        int32_t reboot_ota_seconds;
+        /* This message is only supported for the simulator Portduino build.
+     If received the simulator will exit successfully. */
+        bool exit_simulator;
+        /* Tell the node to reboot in this many seconds (or <0 to cancel reboot) */
+        int32_t reboot_seconds;
+        /* Tell the node to shutdown in this many seconds (or <0 to cancel shutdown) */
+        int32_t shutdown_seconds;
+        /* Tell the node to factory reset, all device settings will be returned to factory defaults. */
+        int32_t factory_reset;
+        /* Tell the node to reset the nodedb. */
+        int32_t nodedb_reset;
+    };
+} meshtastic_AdminMessage;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_AdminMessage_ConfigType_MIN meshtastic_AdminMessage_ConfigType_DEVICE_CONFIG
+#define _meshtastic_AdminMessage_ConfigType_MAX meshtastic_AdminMessage_ConfigType_BLUETOOTH_CONFIG
+#define _meshtastic_AdminMessage_ConfigType_ARRAYSIZE ((meshtastic_AdminMessage_ConfigType)(meshtastic_AdminMessage_ConfigType_BLUETOOTH_CONFIG+1))
+
+#define _meshtastic_AdminMessage_ModuleConfigType_MIN meshtastic_AdminMessage_ModuleConfigType_MQTT_CONFIG
+#define _meshtastic_AdminMessage_ModuleConfigType_MAX meshtastic_AdminMessage_ModuleConfigType_PAXCOUNTER_CONFIG
+#define _meshtastic_AdminMessage_ModuleConfigType_ARRAYSIZE ((meshtastic_AdminMessage_ModuleConfigType)(meshtastic_AdminMessage_ModuleConfigType_PAXCOUNTER_CONFIG+1))
+
+#define meshtastic_AdminMessage_payload_variant_get_config_request_ENUMTYPE meshtastic_AdminMessage_ConfigType
+#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_NodeRemoteHardwarePinsResponse_init_default {0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}}
+#define meshtastic_AdminMessage_init_zero        {0, {0}}
+#define meshtastic_HamParameters_init_zero       {"", 0, 0, ""}
+#define meshtastic_NodeRemoteHardwarePinsResponse_init_zero {0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}}
+
+/* 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_NodeRemoteHardwarePinsResponse_node_remote_hardware_pins_tag 1
+#define meshtastic_AdminMessage_get_channel_request_tag 1
+#define meshtastic_AdminMessage_get_channel_response_tag 2
+#define meshtastic_AdminMessage_get_owner_request_tag 3
+#define meshtastic_AdminMessage_get_owner_response_tag 4
+#define meshtastic_AdminMessage_get_config_request_tag 5
+#define meshtastic_AdminMessage_get_config_response_tag 6
+#define meshtastic_AdminMessage_get_module_config_request_tag 7
+#define meshtastic_AdminMessage_get_module_config_response_tag 8
+#define meshtastic_AdminMessage_get_canned_message_module_messages_request_tag 10
+#define meshtastic_AdminMessage_get_canned_message_module_messages_response_tag 11
+#define meshtastic_AdminMessage_get_device_metadata_request_tag 12
+#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_get_node_remote_hardware_pins_request_tag 19
+#define meshtastic_AdminMessage_get_node_remote_hardware_pins_response_tag 20
+#define meshtastic_AdminMessage_enter_dfu_mode_request_tag 21
+#define meshtastic_AdminMessage_delete_file_request_tag 22
+#define meshtastic_AdminMessage_set_owner_tag    32
+#define meshtastic_AdminMessage_set_channel_tag  33
+#define meshtastic_AdminMessage_set_config_tag   34
+#define meshtastic_AdminMessage_set_module_config_tag 35
+#define meshtastic_AdminMessage_set_canned_message_module_messages_tag 36
+#define meshtastic_AdminMessage_set_ringtone_message_tag 37
+#define meshtastic_AdminMessage_remove_by_nodenum_tag 38
+#define meshtastic_AdminMessage_set_favorite_node_tag 39
+#define meshtastic_AdminMessage_remove_favorite_node_tag 40
+#define meshtastic_AdminMessage_set_fixed_position_tag 41
+#define meshtastic_AdminMessage_remove_fixed_position_tag 42
+#define meshtastic_AdminMessage_begin_edit_settings_tag 64
+#define meshtastic_AdminMessage_commit_edit_settings_tag 65
+#define meshtastic_AdminMessage_reboot_ota_seconds_tag 95
+#define meshtastic_AdminMessage_exit_simulator_tag 96
+#define meshtastic_AdminMessage_reboot_seconds_tag 97
+#define meshtastic_AdminMessage_shutdown_seconds_tag 98
+#define meshtastic_AdminMessage_factory_reset_tag 99
+#define meshtastic_AdminMessage_nodedb_reset_tag 100
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_AdminMessage_FIELDLIST(X, a) \
+X(a, STATIC,   ONEOF,    UINT32,   (payload_variant,get_channel_request,get_channel_request),   1) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,get_channel_response,get_channel_response),   2) \
+X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,get_owner_request,get_owner_request),   3) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,get_owner_response,get_owner_response),   4) \
+X(a, STATIC,   ONEOF,    UENUM,    (payload_variant,get_config_request,get_config_request),   5) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,get_config_response,get_config_response),   6) \
+X(a, STATIC,   ONEOF,    UENUM,    (payload_variant,get_module_config_request,get_module_config_request),   7) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,get_module_config_response,get_module_config_response),   8) \
+X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,get_canned_message_module_messages_request,get_canned_message_module_messages_request),  10) \
+X(a, STATIC,   ONEOF,    STRING,   (payload_variant,get_canned_message_module_messages_response,get_canned_message_module_messages_response),  11) \
+X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,get_device_metadata_request,get_device_metadata_request),  12) \
+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,    BOOL,     (payload_variant,get_node_remote_hardware_pins_request,get_node_remote_hardware_pins_request),  19) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,get_node_remote_hardware_pins_response,get_node_remote_hardware_pins_response),  20) \
+X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,enter_dfu_mode_request,enter_dfu_mode_request),  21) \
+X(a, STATIC,   ONEOF,    STRING,   (payload_variant,delete_file_request,delete_file_request),  22) \
+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) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,set_module_config,set_module_config),  35) \
+X(a, STATIC,   ONEOF,    STRING,   (payload_variant,set_canned_message_module_messages,set_canned_message_module_messages),  36) \
+X(a, STATIC,   ONEOF,    STRING,   (payload_variant,set_ringtone_message,set_ringtone_message),  37) \
+X(a, STATIC,   ONEOF,    UINT32,   (payload_variant,remove_by_nodenum,remove_by_nodenum),  38) \
+X(a, STATIC,   ONEOF,    UINT32,   (payload_variant,set_favorite_node,set_favorite_node),  39) \
+X(a, STATIC,   ONEOF,    UINT32,   (payload_variant,remove_favorite_node,remove_favorite_node),  40) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,set_fixed_position,set_fixed_position),  41) \
+X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,remove_fixed_position,remove_fixed_position),  42) \
+X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,begin_edit_settings,begin_edit_settings),  64) \
+X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,commit_edit_settings,commit_edit_settings),  65) \
+X(a, STATIC,   ONEOF,    INT32,    (payload_variant,reboot_ota_seconds,reboot_ota_seconds),  95) \
+X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,exit_simulator,exit_simulator),  96) \
+X(a, STATIC,   ONEOF,    INT32,    (payload_variant,reboot_seconds,reboot_seconds),  97) \
+X(a, STATIC,   ONEOF,    INT32,    (payload_variant,shutdown_seconds,shutdown_seconds),  98) \
+X(a, STATIC,   ONEOF,    INT32,    (payload_variant,factory_reset,factory_reset),  99) \
+X(a, STATIC,   ONEOF,    INT32,    (payload_variant,nodedb_reset,nodedb_reset), 100)
+#define meshtastic_AdminMessage_CALLBACK NULL
+#define meshtastic_AdminMessage_DEFAULT NULL
+#define meshtastic_AdminMessage_payload_variant_get_channel_response_MSGTYPE meshtastic_Channel
+#define meshtastic_AdminMessage_payload_variant_get_owner_response_MSGTYPE meshtastic_User
+#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_get_node_remote_hardware_pins_response_MSGTYPE meshtastic_NodeRemoteHardwarePinsResponse
+#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_AdminMessage_payload_variant_set_fixed_position_MSGTYPE meshtastic_Position
+
+#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
+
+#define meshtastic_NodeRemoteHardwarePinsResponse_FIELDLIST(X, a) \
+X(a, STATIC,   REPEATED, MESSAGE,  node_remote_hardware_pins,   1)
+#define meshtastic_NodeRemoteHardwarePinsResponse_CALLBACK NULL
+#define meshtastic_NodeRemoteHardwarePinsResponse_DEFAULT NULL
+#define meshtastic_NodeRemoteHardwarePinsResponse_node_remote_hardware_pins_MSGTYPE meshtastic_NodeRemoteHardwarePin
+
+extern const pb_msgdesc_t meshtastic_AdminMessage_msg;
+extern const pb_msgdesc_t meshtastic_HamParameters_msg;
+extern const pb_msgdesc_t meshtastic_NodeRemoteHardwarePinsResponse_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
+#define meshtastic_NodeRemoteHardwarePinsResponse_fields &meshtastic_NodeRemoteHardwarePinsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_ADMIN_PB_H_MAX_SIZE meshtastic_AdminMessage_size
+#define meshtastic_AdminMessage_size             500
+#define meshtastic_HamParameters_size            32
+#define meshtastic_NodeRemoteHardwarePinsResponse_size 496
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

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

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

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

@@ -0,0 +1,64 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_APPONLY_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_APPONLY_PB_H_INCLUDED
+#include <pb.h>
+#include "meshtastic/channel.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 */
+/* This is the most compact possible representation for a set of channels.
+ It includes only one PRIMARY channel (which must be first) and
+ any SECONDARY channels.
+ No DISABLED channels are included.
+ This abstraction is used only on the the 'app side' of the world (ie python, javascript and android etc) to show a group of Channels as a (long) URL */
+typedef struct _meshtastic_ChannelSet {
+    /* Channel list with settings */
+    pb_size_t settings_count;
+    meshtastic_ChannelSettings settings[8];
+    /* LoRa config */
+    bool has_lora_config;
+    meshtastic_Config_LoRaConfig lora_config;
+} meshtastic_ChannelSet;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define meshtastic_ChannelSet_init_default       {0, {meshtastic_ChannelSettings_init_default, meshtastic_ChannelSettings_init_default, meshtastic_ChannelSettings_init_default, meshtastic_ChannelSettings_init_default, meshtastic_ChannelSettings_init_default, meshtastic_ChannelSettings_init_default, meshtastic_ChannelSettings_init_default, meshtastic_ChannelSettings_init_default}, false, meshtastic_Config_LoRaConfig_init_default}
+#define meshtastic_ChannelSet_init_zero          {0, {meshtastic_ChannelSettings_init_zero, meshtastic_ChannelSettings_init_zero, meshtastic_ChannelSettings_init_zero, meshtastic_ChannelSettings_init_zero, meshtastic_ChannelSettings_init_zero, meshtastic_ChannelSettings_init_zero, meshtastic_ChannelSettings_init_zero, meshtastic_ChannelSettings_init_zero}, false, meshtastic_Config_LoRaConfig_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_ChannelSet_settings_tag       1
+#define meshtastic_ChannelSet_lora_config_tag    2
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_ChannelSet_FIELDLIST(X, a) \
+X(a, STATIC,   REPEATED, MESSAGE,  settings,          1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  lora_config,       2)
+#define meshtastic_ChannelSet_CALLBACK NULL
+#define meshtastic_ChannelSet_DEFAULT NULL
+#define meshtastic_ChannelSet_settings_MSGTYPE meshtastic_ChannelSettings
+#define meshtastic_ChannelSet_lora_config_MSGTYPE meshtastic_Config_LoRaConfig
+
+extern const pb_msgdesc_t meshtastic_ChannelSet_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_ChannelSet_fields &meshtastic_ChannelSet_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_APPONLY_PB_H_MAX_SIZE meshtastic_ChannelSet_size
+#define meshtastic_ChannelSet_size               658
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/atak.pb.cpp

@@ -0,0 +1,29 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#include "meshtastic/atak.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_TAKPacket, meshtastic_TAKPacket, 2)
+
+
+PB_BIND(meshtastic_GeoChat, meshtastic_GeoChat, 2)
+
+
+PB_BIND(meshtastic_Group, meshtastic_Group, AUTO)
+
+
+PB_BIND(meshtastic_Status, meshtastic_Status, AUTO)
+
+
+PB_BIND(meshtastic_Contact, meshtastic_Contact, AUTO)
+
+
+PB_BIND(meshtastic_PLI, meshtastic_PLI, AUTO)
+
+
+
+
+

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

@@ -0,0 +1,275 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_ATAK_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_ATAK_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _meshtastic_Team {
+    /* Unspecifed */
+    meshtastic_Team_Unspecifed_Color = 0,
+    /* White */
+    meshtastic_Team_White = 1,
+    /* Yellow */
+    meshtastic_Team_Yellow = 2,
+    /* Orange */
+    meshtastic_Team_Orange = 3,
+    /* Magenta */
+    meshtastic_Team_Magenta = 4,
+    /* Red */
+    meshtastic_Team_Red = 5,
+    /* Maroon */
+    meshtastic_Team_Maroon = 6,
+    /* Purple */
+    meshtastic_Team_Purple = 7,
+    /* Dark Blue */
+    meshtastic_Team_Dark_Blue = 8,
+    /* Blue */
+    meshtastic_Team_Blue = 9,
+    /* Cyan */
+    meshtastic_Team_Cyan = 10,
+    /* Teal */
+    meshtastic_Team_Teal = 11,
+    /* Green */
+    meshtastic_Team_Green = 12,
+    /* Dark Green */
+    meshtastic_Team_Dark_Green = 13,
+    /* Brown */
+    meshtastic_Team_Brown = 14
+} meshtastic_Team;
+
+/* Role of the group member */
+typedef enum _meshtastic_MemberRole {
+    /* Unspecifed */
+    meshtastic_MemberRole_Unspecifed = 0,
+    /* Team Member */
+    meshtastic_MemberRole_TeamMember = 1,
+    /* Team Lead */
+    meshtastic_MemberRole_TeamLead = 2,
+    /* Headquarters */
+    meshtastic_MemberRole_HQ = 3,
+    /* Airsoft enthusiast */
+    meshtastic_MemberRole_Sniper = 4,
+    /* Medic */
+    meshtastic_MemberRole_Medic = 5,
+    /* ForwardObserver */
+    meshtastic_MemberRole_ForwardObserver = 6,
+    /* Radio Telephone Operator */
+    meshtastic_MemberRole_RTO = 7,
+    /* Doggo */
+    meshtastic_MemberRole_K9 = 8
+} meshtastic_MemberRole;
+
+/* Struct definitions */
+/* ATAK GeoChat message */
+typedef struct _meshtastic_GeoChat {
+    /* The text message */
+    char message[200];
+    /* Uid recipient of the message */
+    bool has_to;
+    char to[120];
+} meshtastic_GeoChat;
+
+/* ATAK Group
+ <__group role='Team Member' name='Cyan'/> */
+typedef struct _meshtastic_Group {
+    /* Role of the group member */
+    meshtastic_MemberRole role;
+    /* Team (color)
+ Default Cyan */
+    meshtastic_Team team;
+} meshtastic_Group;
+
+/* ATAK EUD Status
+ <status battery='100' /> */
+typedef struct _meshtastic_Status {
+    /* Battery level */
+    uint8_t battery;
+} meshtastic_Status;
+
+/* ATAK Contact
+ <contact endpoint='0.0.0.0:4242:tcp' phone='+12345678' callsign='FALKE'/> */
+typedef struct _meshtastic_Contact {
+    /* Callsign */
+    char callsign[120];
+    /* Device callsign */
+    char device_callsign[120]; /* IP address of endpoint in integer form (0.0.0.0 default) */
+} meshtastic_Contact;
+
+/* Position Location Information from ATAK */
+typedef struct _meshtastic_PLI {
+    /* The new preferred location encoding, multiply by 1e-7 to get degrees
+ in floating point */
+    int32_t latitude_i;
+    /* The new preferred location encoding, multiply by 1e-7 to get degrees
+ in floating point */
+    int32_t longitude_i;
+    /* Altitude (ATAK prefers HAE) */
+    int32_t altitude;
+    /* Speed */
+    uint32_t speed;
+    /* Course in degrees */
+    uint16_t course;
+} meshtastic_PLI;
+
+/* Packets for the official ATAK Plugin */
+typedef struct _meshtastic_TAKPacket {
+    /* Are the payloads strings compressed for LoRA transport? */
+    bool is_compressed;
+    /* The contact / callsign for ATAK user */
+    bool has_contact;
+    meshtastic_Contact contact;
+    /* The group for ATAK user */
+    bool has_group;
+    meshtastic_Group group;
+    /* The status of the ATAK EUD */
+    bool has_status;
+    meshtastic_Status status;
+    pb_size_t which_payload_variant;
+    union {
+        /* TAK position report */
+        meshtastic_PLI pli;
+        /* ATAK GeoChat message */
+        meshtastic_GeoChat chat;
+    } payload_variant;
+} meshtastic_TAKPacket;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_Team_MIN meshtastic_Team_Unspecifed_Color
+#define _meshtastic_Team_MAX meshtastic_Team_Brown
+#define _meshtastic_Team_ARRAYSIZE ((meshtastic_Team)(meshtastic_Team_Brown+1))
+
+#define _meshtastic_MemberRole_MIN meshtastic_MemberRole_Unspecifed
+#define _meshtastic_MemberRole_MAX meshtastic_MemberRole_K9
+#define _meshtastic_MemberRole_ARRAYSIZE ((meshtastic_MemberRole)(meshtastic_MemberRole_K9+1))
+
+
+
+#define meshtastic_Group_role_ENUMTYPE meshtastic_MemberRole
+#define meshtastic_Group_team_ENUMTYPE meshtastic_Team
+
+
+
+
+
+/* Initializer values for message structs */
+#define meshtastic_TAKPacket_init_default        {0, false, meshtastic_Contact_init_default, false, meshtastic_Group_init_default, false, meshtastic_Status_init_default, 0, {meshtastic_PLI_init_default}}
+#define meshtastic_GeoChat_init_default          {"", false, ""}
+#define meshtastic_Group_init_default            {_meshtastic_MemberRole_MIN, _meshtastic_Team_MIN}
+#define meshtastic_Status_init_default           {0}
+#define meshtastic_Contact_init_default          {"", ""}
+#define meshtastic_PLI_init_default              {0, 0, 0, 0, 0}
+#define meshtastic_TAKPacket_init_zero           {0, false, meshtastic_Contact_init_zero, false, meshtastic_Group_init_zero, false, meshtastic_Status_init_zero, 0, {meshtastic_PLI_init_zero}}
+#define meshtastic_GeoChat_init_zero             {"", false, ""}
+#define meshtastic_Group_init_zero               {_meshtastic_MemberRole_MIN, _meshtastic_Team_MIN}
+#define meshtastic_Status_init_zero              {0}
+#define meshtastic_Contact_init_zero             {"", ""}
+#define meshtastic_PLI_init_zero                 {0, 0, 0, 0, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_GeoChat_message_tag           1
+#define meshtastic_GeoChat_to_tag                2
+#define meshtastic_Group_role_tag                1
+#define meshtastic_Group_team_tag                2
+#define meshtastic_Status_battery_tag            1
+#define meshtastic_Contact_callsign_tag          1
+#define meshtastic_Contact_device_callsign_tag   2
+#define meshtastic_PLI_latitude_i_tag            1
+#define meshtastic_PLI_longitude_i_tag           2
+#define meshtastic_PLI_altitude_tag              3
+#define meshtastic_PLI_speed_tag                 4
+#define meshtastic_PLI_course_tag                5
+#define meshtastic_TAKPacket_is_compressed_tag   1
+#define meshtastic_TAKPacket_contact_tag         2
+#define meshtastic_TAKPacket_group_tag           3
+#define meshtastic_TAKPacket_status_tag          4
+#define meshtastic_TAKPacket_pli_tag             5
+#define meshtastic_TAKPacket_chat_tag            6
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_TAKPacket_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     is_compressed,     1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  contact,           2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  group,             3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  status,            4) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,pli,payload_variant.pli),   5) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,chat,payload_variant.chat),   6)
+#define meshtastic_TAKPacket_CALLBACK NULL
+#define meshtastic_TAKPacket_DEFAULT NULL
+#define meshtastic_TAKPacket_contact_MSGTYPE meshtastic_Contact
+#define meshtastic_TAKPacket_group_MSGTYPE meshtastic_Group
+#define meshtastic_TAKPacket_status_MSGTYPE meshtastic_Status
+#define meshtastic_TAKPacket_payload_variant_pli_MSGTYPE meshtastic_PLI
+#define meshtastic_TAKPacket_payload_variant_chat_MSGTYPE meshtastic_GeoChat
+
+#define meshtastic_GeoChat_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, STRING,   message,           1) \
+X(a, STATIC,   OPTIONAL, STRING,   to,                2)
+#define meshtastic_GeoChat_CALLBACK NULL
+#define meshtastic_GeoChat_DEFAULT NULL
+
+#define meshtastic_Group_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    role,              1) \
+X(a, STATIC,   SINGULAR, UENUM,    team,              2)
+#define meshtastic_Group_CALLBACK NULL
+#define meshtastic_Group_DEFAULT NULL
+
+#define meshtastic_Status_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   battery,           1)
+#define meshtastic_Status_CALLBACK NULL
+#define meshtastic_Status_DEFAULT NULL
+
+#define meshtastic_Contact_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, STRING,   callsign,          1) \
+X(a, STATIC,   SINGULAR, STRING,   device_callsign,   2)
+#define meshtastic_Contact_CALLBACK NULL
+#define meshtastic_Contact_DEFAULT NULL
+
+#define meshtastic_PLI_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, SFIXED32, latitude_i,        1) \
+X(a, STATIC,   SINGULAR, SFIXED32, longitude_i,       2) \
+X(a, STATIC,   SINGULAR, INT32,    altitude,          3) \
+X(a, STATIC,   SINGULAR, UINT32,   speed,             4) \
+X(a, STATIC,   SINGULAR, UINT32,   course,            5)
+#define meshtastic_PLI_CALLBACK NULL
+#define meshtastic_PLI_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_TAKPacket_msg;
+extern const pb_msgdesc_t meshtastic_GeoChat_msg;
+extern const pb_msgdesc_t meshtastic_Group_msg;
+extern const pb_msgdesc_t meshtastic_Status_msg;
+extern const pb_msgdesc_t meshtastic_Contact_msg;
+extern const pb_msgdesc_t meshtastic_PLI_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_TAKPacket_fields &meshtastic_TAKPacket_msg
+#define meshtastic_GeoChat_fields &meshtastic_GeoChat_msg
+#define meshtastic_Group_fields &meshtastic_Group_msg
+#define meshtastic_Status_fields &meshtastic_Status_msg
+#define meshtastic_Contact_fields &meshtastic_Contact_msg
+#define meshtastic_PLI_fields &meshtastic_PLI_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_ATAK_PB_H_MAX_SIZE meshtastic_TAKPacket_size
+#define meshtastic_Contact_size                  242
+#define meshtastic_GeoChat_size                  323
+#define meshtastic_Group_size                    4
+#define meshtastic_PLI_size                      31
+#define meshtastic_Status_size                   3
+#define meshtastic_TAKPacket_size                584
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/cannedmessages.pb.cpp

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

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

@@ -0,0 +1,50 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_CANNEDMESSAGES_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_CANNEDMESSAGES_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 */
+/* Canned message module configuration. */
+typedef struct _meshtastic_CannedMessageModuleConfig {
+    /* Predefined messages for canned message module separated by '|' characters. */
+    char messages[201];
+} meshtastic_CannedMessageModuleConfig;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define meshtastic_CannedMessageModuleConfig_init_default {""}
+#define meshtastic_CannedMessageModuleConfig_init_zero {""}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_CannedMessageModuleConfig_messages_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_CannedMessageModuleConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, STRING,   messages,          1)
+#define meshtastic_CannedMessageModuleConfig_CALLBACK NULL
+#define meshtastic_CannedMessageModuleConfig_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_CannedMessageModuleConfig_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_CannedMessageModuleConfig_fields &meshtastic_CannedMessageModuleConfig_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_CANNEDMESSAGES_PB_H_MAX_SIZE meshtastic_CannedMessageModuleConfig_size
+#define meshtastic_CannedMessageModuleConfig_size 203
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/channel.pb.cpp

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

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

@@ -0,0 +1,193 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_CHANNEL_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_CHANNEL_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+/* How this channel is being used (or not).
+ Note: this field is an enum to give us options for the future.
+ In particular, someday we might make a 'SCANNING' option.
+ SCANNING channels could have different frequencies and the radio would
+ occasionally check that freq to see if anything is being transmitted.
+ For devices that have multiple physical radios attached, we could keep multiple PRIMARY/SCANNING channels active at once to allow
+ cross band routing as needed.
+ If a device has only a single radio (the common case) only one channel can be PRIMARY at a time
+ (but any number of SECONDARY channels can't be sent received on that common frequency) */
+typedef enum _meshtastic_Channel_Role {
+    /* This channel is not in use right now */
+    meshtastic_Channel_Role_DISABLED = 0,
+    /* This channel is used to set the frequency for the radio - all other enabled channels must be SECONDARY */
+    meshtastic_Channel_Role_PRIMARY = 1,
+    /* Secondary channels are only used for encryption/decryption/authentication purposes.
+ Their radio settings (freq etc) are ignored, only psk is used. */
+    meshtastic_Channel_Role_SECONDARY = 2
+} meshtastic_Channel_Role;
+
+/* Struct definitions */
+/* This message is specifically for modules to store per-channel configuration data. */
+typedef struct _meshtastic_ModuleSettings {
+    /* Bits of precision for the location sent in position packets. */
+    uint32_t position_precision;
+} meshtastic_ModuleSettings;
+
+typedef PB_BYTES_ARRAY_T(32) meshtastic_ChannelSettings_psk_t;
+/* This information can be encoded as a QRcode/url so that other users can configure
+ their radio to join the same channel.
+ A note about how channel names are shown to users: channelname-X
+ poundsymbol is a prefix used to indicate this is a channel name (idea from @professr).
+ Where X is a letter from A-Z (base 26) representing a hash of the PSK for this
+ channel - so that if the user changes anything about the channel (which does
+ force a new PSK) this letter will also change. Thus preventing user confusion if
+ two friends try to type in a channel name of "BobsChan" and then can't talk
+ because their PSKs will be different.
+ The PSK is hashed into this letter by "0x41 + [xor all bytes of the psk ] modulo 26"
+ This also allows the option of someday if people have the PSK off (zero), the
+ users COULD type in a channel name and be able to talk.
+ FIXME: Add description of multi-channel support and how primary vs secondary channels are used.
+ FIXME: explain how apps use channels for security.
+ explain how remote settings and remote gpio are managed as an example */
+typedef struct _meshtastic_ChannelSettings {
+    /* Deprecated in favor of LoraConfig.channel_num */
+    uint32_t channel_num;
+    /* A simple pre-shared key for now for crypto.
+ Must be either 0 bytes (no crypto), 16 bytes (AES128), or 32 bytes (AES256).
+ A special shorthand is used for 1 byte long psks.
+ These psks should be treated as only minimally secure,
+ because they are listed in this source code.
+ Those bytes are mapped using the following scheme:
+ `0` = No crypto
+ `1` = The special "default" channel key: {0xd4, 0xf1, 0xbb, 0x3a, 0x20, 0x29, 0x07, 0x59, 0xf0, 0xbc, 0xff, 0xab, 0xcf, 0x4e, 0x69, 0x01}
+ `2` through 10 = The default channel key, except with 1 through 9 added to the last byte.
+ Shown to user as simple1 through 10 */
+    meshtastic_ChannelSettings_psk_t psk;
+    /* A SHORT name that will be packed into the URL.
+ Less than 12 bytes.
+ Something for end users to call the channel
+ If this is the empty string it is assumed that this channel
+ is the special (minimally secure) "Default"channel.
+ In user interfaces it should be rendered as a local language translation of "X".
+ For channel_num hashing empty string will be treated as "X".
+ Where "X" is selected based on the English words listed above for ModemPreset */
+    char name[12];
+    /* Used to construct a globally unique channel ID.
+ The full globally unique ID will be: "name.id" where ID is shown as base36.
+ Assuming that the number of meshtastic users is below 20K (true for a long time)
+ the chance of this 64 bit random number colliding with anyone else is super low.
+ And the penalty for collision is low as well, it just means that anyone trying to decrypt channel messages might need to
+ try multiple candidate channels.
+ Any time a non wire compatible change is made to a channel, this field should be regenerated.
+ There are a small number of 'special' globally known (and fairly) insecure standard channels.
+ Those channels do not have a numeric id included in the settings, but instead it is pulled from
+ a table of well known IDs.
+ (see Well Known Channels FIXME) */
+    uint32_t id;
+    /* If true, messages on the mesh will be sent to the *public* internet by any gateway ndoe */
+    bool uplink_enabled;
+    /* If true, messages seen on the internet will be forwarded to the local mesh. */
+    bool downlink_enabled;
+    /* Per-channel module settings. */
+    bool has_module_settings;
+    meshtastic_ModuleSettings module_settings;
+} meshtastic_ChannelSettings;
+
+/* A pair of a channel number, mode and the (sharable) settings for that channel */
+typedef struct _meshtastic_Channel {
+    /* The index of this channel in the channel table (from 0 to MAX_NUM_CHANNELS-1)
+ (Someday - not currently implemented) An index of -1 could be used to mean "set by name",
+ in which case the target node will find and set the channel by settings.name. */
+    int8_t index;
+    /* The new settings, or NULL to disable that channel */
+    bool has_settings;
+    meshtastic_ChannelSettings settings;
+    /* TODO: REPLACE */
+    meshtastic_Channel_Role role;
+} meshtastic_Channel;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_Channel_Role_MIN meshtastic_Channel_Role_DISABLED
+#define _meshtastic_Channel_Role_MAX meshtastic_Channel_Role_SECONDARY
+#define _meshtastic_Channel_Role_ARRAYSIZE ((meshtastic_Channel_Role)(meshtastic_Channel_Role_SECONDARY+1))
+
+
+
+#define meshtastic_Channel_role_ENUMTYPE meshtastic_Channel_Role
+
+
+/* Initializer values for message structs */
+#define meshtastic_ChannelSettings_init_default  {0, {0, {0}}, "", 0, 0, 0, false, meshtastic_ModuleSettings_init_default}
+#define meshtastic_ModuleSettings_init_default   {0}
+#define meshtastic_Channel_init_default          {0, false, meshtastic_ChannelSettings_init_default, _meshtastic_Channel_Role_MIN}
+#define meshtastic_ChannelSettings_init_zero     {0, {0, {0}}, "", 0, 0, 0, false, meshtastic_ModuleSettings_init_zero}
+#define meshtastic_ModuleSettings_init_zero      {0}
+#define meshtastic_Channel_init_zero             {0, false, meshtastic_ChannelSettings_init_zero, _meshtastic_Channel_Role_MIN}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_ModuleSettings_position_precision_tag 1
+#define meshtastic_ChannelSettings_channel_num_tag 1
+#define meshtastic_ChannelSettings_psk_tag       2
+#define meshtastic_ChannelSettings_name_tag      3
+#define meshtastic_ChannelSettings_id_tag        4
+#define meshtastic_ChannelSettings_uplink_enabled_tag 5
+#define meshtastic_ChannelSettings_downlink_enabled_tag 6
+#define meshtastic_ChannelSettings_module_settings_tag 7
+#define meshtastic_Channel_index_tag             1
+#define meshtastic_Channel_settings_tag          2
+#define meshtastic_Channel_role_tag              3
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_ChannelSettings_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   channel_num,       1) \
+X(a, STATIC,   SINGULAR, BYTES,    psk,               2) \
+X(a, STATIC,   SINGULAR, STRING,   name,              3) \
+X(a, STATIC,   SINGULAR, FIXED32,  id,                4) \
+X(a, STATIC,   SINGULAR, BOOL,     uplink_enabled,    5) \
+X(a, STATIC,   SINGULAR, BOOL,     downlink_enabled,   6) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  module_settings,   7)
+#define meshtastic_ChannelSettings_CALLBACK NULL
+#define meshtastic_ChannelSettings_DEFAULT NULL
+#define meshtastic_ChannelSettings_module_settings_MSGTYPE meshtastic_ModuleSettings
+
+#define meshtastic_ModuleSettings_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   position_precision,   1)
+#define meshtastic_ModuleSettings_CALLBACK NULL
+#define meshtastic_ModuleSettings_DEFAULT NULL
+
+#define meshtastic_Channel_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, INT32,    index,             1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  settings,          2) \
+X(a, STATIC,   SINGULAR, UENUM,    role,              3)
+#define meshtastic_Channel_CALLBACK NULL
+#define meshtastic_Channel_DEFAULT NULL
+#define meshtastic_Channel_settings_MSGTYPE meshtastic_ChannelSettings
+
+extern const pb_msgdesc_t meshtastic_ChannelSettings_msg;
+extern const pb_msgdesc_t meshtastic_ModuleSettings_msg;
+extern const pb_msgdesc_t meshtastic_Channel_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_ChannelSettings_fields &meshtastic_ChannelSettings_msg
+#define meshtastic_ModuleSettings_fields &meshtastic_ModuleSettings_msg
+#define meshtastic_Channel_fields &meshtastic_Channel_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_CHANNEL_PB_H_MAX_SIZE meshtastic_Channel_size
+#define meshtastic_ChannelSettings_size          70
+#define meshtastic_Channel_size                  85
+#define meshtastic_ModuleSettings_size           6
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/clientonly.pb.cpp

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

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

@@ -0,0 +1,73 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_CLIENTONLY_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_CLIENTONLY_PB_H_INCLUDED
+#include <pb.h>
+#include "meshtastic/localonly.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+/* This abstraction is used to contain any configuration for provisioning a node on any client.
+ It is useful for importing and exporting configurations. */
+typedef struct _meshtastic_DeviceProfile {
+    /* Long name for the node */
+    bool has_long_name;
+    char long_name[40];
+    /* Short name of the node */
+    bool has_short_name;
+    char short_name[5];
+    /* The url of the channels from our node */
+    pb_callback_t channel_url;
+    /* The Config of the node */
+    bool has_config;
+    meshtastic_LocalConfig config;
+    /* The ModuleConfig of the node */
+    bool has_module_config;
+    meshtastic_LocalModuleConfig module_config;
+} meshtastic_DeviceProfile;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define meshtastic_DeviceProfile_init_default    {false, "", false, "", {{NULL}, NULL}, false, meshtastic_LocalConfig_init_default, false, meshtastic_LocalModuleConfig_init_default}
+#define meshtastic_DeviceProfile_init_zero       {false, "", false, "", {{NULL}, NULL}, false, meshtastic_LocalConfig_init_zero, false, meshtastic_LocalModuleConfig_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_DeviceProfile_long_name_tag   1
+#define meshtastic_DeviceProfile_short_name_tag  2
+#define meshtastic_DeviceProfile_channel_url_tag 3
+#define meshtastic_DeviceProfile_config_tag      4
+#define meshtastic_DeviceProfile_module_config_tag 5
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_DeviceProfile_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, STRING,   long_name,         1) \
+X(a, STATIC,   OPTIONAL, STRING,   short_name,        2) \
+X(a, CALLBACK, OPTIONAL, STRING,   channel_url,       3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  config,            4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  module_config,     5)
+#define meshtastic_DeviceProfile_CALLBACK pb_default_field_callback
+#define meshtastic_DeviceProfile_DEFAULT NULL
+#define meshtastic_DeviceProfile_config_MSGTYPE meshtastic_LocalConfig
+#define meshtastic_DeviceProfile_module_config_MSGTYPE meshtastic_LocalModuleConfig
+
+extern const pb_msgdesc_t meshtastic_DeviceProfile_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_DeviceProfile_fields &meshtastic_DeviceProfile_msg
+
+/* Maximum encoded size of messages (where known) */
+/* meshtastic_DeviceProfile_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

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

@@ -0,0 +1,48 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#include "meshtastic/config.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_Config, meshtastic_Config, AUTO)
+
+
+PB_BIND(meshtastic_Config_DeviceConfig, meshtastic_Config_DeviceConfig, AUTO)
+
+
+PB_BIND(meshtastic_Config_PositionConfig, meshtastic_Config_PositionConfig, AUTO)
+
+
+PB_BIND(meshtastic_Config_PowerConfig, meshtastic_Config_PowerConfig, AUTO)
+
+
+PB_BIND(meshtastic_Config_NetworkConfig, meshtastic_Config_NetworkConfig, AUTO)
+
+
+PB_BIND(meshtastic_Config_NetworkConfig_IpV4Config, meshtastic_Config_NetworkConfig_IpV4Config, AUTO)
+
+
+PB_BIND(meshtastic_Config_DisplayConfig, meshtastic_Config_DisplayConfig, AUTO)
+
+
+PB_BIND(meshtastic_Config_LoRaConfig, meshtastic_Config_LoRaConfig, 2)
+
+
+PB_BIND(meshtastic_Config_BluetoothConfig, meshtastic_Config_BluetoothConfig, AUTO)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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

@@ -0,0 +1,850 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_CONFIG_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_CONFIG_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+/* Defines the device's role on the Mesh network */
+typedef enum _meshtastic_Config_DeviceConfig_Role {
+    /* Description: App connected or stand alone messaging device.
+ Technical Details: Default Role */
+    meshtastic_Config_DeviceConfig_Role_CLIENT = 0,
+    /* Description: Device that does not forward packets from other devices. */
+    meshtastic_Config_DeviceConfig_Role_CLIENT_MUTE = 1,
+    /* Description: Infrastructure node for extending network coverage by relaying messages. Visible in Nodes list.
+ Technical Details: Mesh packets will prefer to be routed over this node. This node will not be used by client apps.
+   The wifi radio and the oled screen will be put to sleep.
+   This mode may still potentially have higher power usage due to it's preference in message rebroadcasting on the mesh. */
+    meshtastic_Config_DeviceConfig_Role_ROUTER = 2,
+    /* Description: Combination of both ROUTER and CLIENT. Not for mobile devices. */
+    meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT = 3,
+    /* Description: Infrastructure node for extending network coverage by relaying messages with minimal overhead. Not visible in Nodes list.
+ Technical Details: Mesh packets will simply be rebroadcasted over this node. Nodes configured with this role will not originate NodeInfo, Position, Telemetry
+   or any other packet type. They will simply rebroadcast any mesh packets on the same frequency, channel num, spread factor, and coding rate. */
+    meshtastic_Config_DeviceConfig_Role_REPEATER = 4,
+    /* Description: Broadcasts GPS position packets as priority.
+ Technical Details: Position Mesh packets will be prioritized higher and sent more frequently by default.
+   When used in conjunction with power.is_power_saving = true, nodes will wake up,
+   send position, and then sleep for position.position_broadcast_secs seconds. */
+    meshtastic_Config_DeviceConfig_Role_TRACKER = 5,
+    /* Description: Broadcasts telemetry packets as priority.
+ Technical Details: Telemetry Mesh packets will be prioritized higher and sent more frequently by default.
+   When used in conjunction with power.is_power_saving = true, nodes will wake up,
+   send environment telemetry, and then sleep for telemetry.environment_update_interval seconds. */
+    meshtastic_Config_DeviceConfig_Role_SENSOR = 6,
+    /* Description: Optimized for ATAK system communication and reduces routine broadcasts.
+ Technical Details: Used for nodes dedicated for connection to an ATAK EUD.
+    Turns off many of the routine broadcasts to favor CoT packet stream
+    from the Meshtastic ATAK plugin -> IMeshService -> Node */
+    meshtastic_Config_DeviceConfig_Role_TAK = 7,
+    /* Description: Device that only broadcasts as needed for stealth or power savings.
+ Technical Details: Used for nodes that "only speak when spoken to"
+    Turns all of the routine broadcasts but allows for ad-hoc communication
+    Still rebroadcasts, but with local only rebroadcast mode (known meshes only)
+    Can be used for clandestine operation or to dramatically reduce airtime / power consumption */
+    meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN = 8,
+    /* Description: Broadcasts location as message to default channel regularly for to assist with device recovery.
+ Technical Details: Used to automatically send a text message to the mesh
+    with the current position of the device on a frequent interval:
+    "I'm lost! Position: lat / long" */
+    meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND = 9,
+    /* Description: Enables automatic TAK PLI broadcasts and reduces routine broadcasts.
+ Technical Details: Turns off many of the routine broadcasts to favor ATAK CoT packet stream
+    and automatic TAK PLI (position location information) broadcasts.
+    Uses position module configuration to determine TAK PLI broadcast interval. */
+    meshtastic_Config_DeviceConfig_Role_TAK_TRACKER = 10
+} meshtastic_Config_DeviceConfig_Role;
+
+/* Defines the device's behavior for how messages are rebroadcast */
+typedef enum _meshtastic_Config_DeviceConfig_RebroadcastMode {
+    /* Default behavior.
+ Rebroadcast any observed message, if it was on our private channel or from another mesh with the same lora params. */
+    meshtastic_Config_DeviceConfig_RebroadcastMode_ALL = 0,
+    /* Same as behavior as ALL but skips packet decoding and simply rebroadcasts them.
+ Only available in Repeater role. Setting this on any other roles will result in ALL behavior. */
+    meshtastic_Config_DeviceConfig_RebroadcastMode_ALL_SKIP_DECODING = 1,
+    /* Ignores observed messages from foreign meshes that are open or those which it cannot decrypt.
+ Only rebroadcasts message on the nodes local primary / secondary channels. */
+    meshtastic_Config_DeviceConfig_RebroadcastMode_LOCAL_ONLY = 2,
+    /* Ignores observed messages from foreign meshes like LOCAL_ONLY,
+ but takes it step further by also ignoring messages from nodenums not in the node's known list (NodeDB) */
+    meshtastic_Config_DeviceConfig_RebroadcastMode_KNOWN_ONLY = 3
+} meshtastic_Config_DeviceConfig_RebroadcastMode;
+
+/* Bit field of boolean configuration options, indicating which optional
+ fields to include when assembling POSITION messages.
+ Longitude, latitude, altitude, speed, heading, and DOP
+ are always included (also time if GPS-synced)
+ NOTE: the more fields are included, the larger the message will be -
+   leading to longer airtime and a higher risk of packet loss */
+typedef enum _meshtastic_Config_PositionConfig_PositionFlags {
+    /* Required for compilation */
+    meshtastic_Config_PositionConfig_PositionFlags_UNSET = 0,
+    /* Include an altitude value (if available) */
+    meshtastic_Config_PositionConfig_PositionFlags_ALTITUDE = 1,
+    /* Altitude value is MSL */
+    meshtastic_Config_PositionConfig_PositionFlags_ALTITUDE_MSL = 2,
+    /* Include geoidal separation */
+    meshtastic_Config_PositionConfig_PositionFlags_GEOIDAL_SEPARATION = 4,
+    /* Include the DOP value ; PDOP used by default, see below */
+    meshtastic_Config_PositionConfig_PositionFlags_DOP = 8,
+    /* If POS_DOP set, send separate HDOP / VDOP values instead of PDOP */
+    meshtastic_Config_PositionConfig_PositionFlags_HVDOP = 16,
+    /* Include number of "satellites in view" */
+    meshtastic_Config_PositionConfig_PositionFlags_SATINVIEW = 32,
+    /* Include a sequence number incremented per packet */
+    meshtastic_Config_PositionConfig_PositionFlags_SEQ_NO = 64,
+    /* Include positional timestamp (from GPS solution) */
+    meshtastic_Config_PositionConfig_PositionFlags_TIMESTAMP = 128,
+    /* Include positional heading
+ Intended for use with vehicle not walking speeds
+ walking speeds are likely to be error prone like the compass */
+    meshtastic_Config_PositionConfig_PositionFlags_HEADING = 256,
+    /* Include positional speed
+ Intended for use with vehicle not walking speeds
+ walking speeds are likely to be error prone like the compass */
+    meshtastic_Config_PositionConfig_PositionFlags_SPEED = 512
+} meshtastic_Config_PositionConfig_PositionFlags;
+
+typedef enum _meshtastic_Config_PositionConfig_GpsMode {
+    /* GPS is present but disabled */
+    meshtastic_Config_PositionConfig_GpsMode_DISABLED = 0,
+    /* GPS is present and enabled */
+    meshtastic_Config_PositionConfig_GpsMode_ENABLED = 1,
+    /* GPS is not present on the device */
+    meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT = 2
+} meshtastic_Config_PositionConfig_GpsMode;
+
+typedef enum _meshtastic_Config_NetworkConfig_AddressMode {
+    /* obtain ip address via DHCP */
+    meshtastic_Config_NetworkConfig_AddressMode_DHCP = 0,
+    /* use static ip address */
+    meshtastic_Config_NetworkConfig_AddressMode_STATIC = 1
+} meshtastic_Config_NetworkConfig_AddressMode;
+
+/* How the GPS coordinates are displayed on the OLED screen. */
+typedef enum _meshtastic_Config_DisplayConfig_GpsCoordinateFormat {
+    /* GPS coordinates are displayed in the normal decimal degrees format:
+ DD.DDDDDD DDD.DDDDDD */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_DEC = 0,
+    /* GPS coordinates are displayed in the degrees minutes seconds format:
+ DD°MM'SS"C DDD°MM'SS"C, where C is the compass point representing the locations quadrant */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_DMS = 1,
+    /* Universal Transverse Mercator format:
+ ZZB EEEEEE NNNNNNN, where Z is zone, B is band, E is easting, N is northing */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_UTM = 2,
+    /* Military Grid Reference System format:
+ ZZB CD EEEEE NNNNN, where Z is zone, B is band, C is the east 100k square, D is the north 100k square,
+ E is easting, N is northing */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MGRS = 3,
+    /* Open Location Code (aka Plus Codes). */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_OLC = 4,
+    /* Ordnance Survey Grid Reference (the National Grid System of the UK).
+ Format: AB EEEEE NNNNN, where A is the east 100k square, B is the north 100k square,
+ E is the easting, N is the northing */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_OSGR = 5
+} meshtastic_Config_DisplayConfig_GpsCoordinateFormat;
+
+/* Unit display preference */
+typedef enum _meshtastic_Config_DisplayConfig_DisplayUnits {
+    /* Metric (Default) */
+    meshtastic_Config_DisplayConfig_DisplayUnits_METRIC = 0,
+    /* Imperial */
+    meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL = 1
+} meshtastic_Config_DisplayConfig_DisplayUnits;
+
+/* Override OLED outo detect with this if it fails. */
+typedef enum _meshtastic_Config_DisplayConfig_OledType {
+    /* Default / Auto */
+    meshtastic_Config_DisplayConfig_OledType_OLED_AUTO = 0,
+    /* Default / Auto */
+    meshtastic_Config_DisplayConfig_OledType_OLED_SSD1306 = 1,
+    /* Default / Auto */
+    meshtastic_Config_DisplayConfig_OledType_OLED_SH1106 = 2,
+    /* Can not be auto detected but set by proto. Used for 128x128 screens */
+    meshtastic_Config_DisplayConfig_OledType_OLED_SH1107 = 3
+} meshtastic_Config_DisplayConfig_OledType;
+
+typedef enum _meshtastic_Config_DisplayConfig_DisplayMode {
+    /* Default. The old style for the 128x64 OLED screen */
+    meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT = 0,
+    /* Rearrange display elements to cater for bicolor OLED displays */
+    meshtastic_Config_DisplayConfig_DisplayMode_TWOCOLOR = 1,
+    /* Same as TwoColor, but with inverted top bar. Not so good for Epaper displays */
+    meshtastic_Config_DisplayConfig_DisplayMode_INVERTED = 2,
+    /* TFT Full Color Displays (not implemented yet) */
+    meshtastic_Config_DisplayConfig_DisplayMode_COLOR = 3
+} meshtastic_Config_DisplayConfig_DisplayMode;
+
+typedef enum _meshtastic_Config_LoRaConfig_RegionCode {
+    /* Region is not set */
+    meshtastic_Config_LoRaConfig_RegionCode_UNSET = 0,
+    /* United States */
+    meshtastic_Config_LoRaConfig_RegionCode_US = 1,
+    /* European Union 433mhz */
+    meshtastic_Config_LoRaConfig_RegionCode_EU_433 = 2,
+    /* European Union 868mhz */
+    meshtastic_Config_LoRaConfig_RegionCode_EU_868 = 3,
+    /* China */
+    meshtastic_Config_LoRaConfig_RegionCode_CN = 4,
+    /* Japan */
+    meshtastic_Config_LoRaConfig_RegionCode_JP = 5,
+    /* Australia / New Zealand */
+    meshtastic_Config_LoRaConfig_RegionCode_ANZ = 6,
+    /* Korea */
+    meshtastic_Config_LoRaConfig_RegionCode_KR = 7,
+    /* Taiwan */
+    meshtastic_Config_LoRaConfig_RegionCode_TW = 8,
+    /* Russia */
+    meshtastic_Config_LoRaConfig_RegionCode_RU = 9,
+    /* India */
+    meshtastic_Config_LoRaConfig_RegionCode_IN = 10,
+    /* New Zealand 865mhz */
+    meshtastic_Config_LoRaConfig_RegionCode_NZ_865 = 11,
+    /* Thailand */
+    meshtastic_Config_LoRaConfig_RegionCode_TH = 12,
+    /* WLAN Band */
+    meshtastic_Config_LoRaConfig_RegionCode_LORA_24 = 13,
+    /* Ukraine 433mhz */
+    meshtastic_Config_LoRaConfig_RegionCode_UA_433 = 14,
+    /* Ukraine 868mhz */
+    meshtastic_Config_LoRaConfig_RegionCode_UA_868 = 15,
+    /* Malaysia 433mhz */
+    meshtastic_Config_LoRaConfig_RegionCode_MY_433 = 16,
+    /* Malaysia 919mhz */
+    meshtastic_Config_LoRaConfig_RegionCode_MY_919 = 17,
+    /* Singapore 923mhz */
+    meshtastic_Config_LoRaConfig_RegionCode_SG_923 = 18
+} meshtastic_Config_LoRaConfig_RegionCode;
+
+/* Standard predefined channel settings
+ Note: these mappings must match ModemPreset Choice in the device code. */
+typedef enum _meshtastic_Config_LoRaConfig_ModemPreset {
+    /* Long Range - Fast */
+    meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST = 0,
+    /* Long Range - Slow */
+    meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW = 1,
+    /* Very Long Range - Slow */
+    meshtastic_Config_LoRaConfig_ModemPreset_VERY_LONG_SLOW = 2,
+    /* Medium Range - Slow */
+    meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW = 3,
+    /* Medium Range - Fast */
+    meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST = 4,
+    /* Short Range - Slow */
+    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW = 5,
+    /* Short Range - Fast */
+    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST = 6,
+    /* Long Range - Moderately Fast */
+    meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE = 7
+} meshtastic_Config_LoRaConfig_ModemPreset;
+
+typedef enum _meshtastic_Config_BluetoothConfig_PairingMode {
+    /* Device generates a random PIN that will be shown on the screen of the device for pairing */
+    meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN = 0,
+    /* Device requires a specified fixed PIN for pairing */
+    meshtastic_Config_BluetoothConfig_PairingMode_FIXED_PIN = 1,
+    /* Device requires no PIN for pairing */
+    meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN = 2
+} meshtastic_Config_BluetoothConfig_PairingMode;
+
+/* Struct definitions */
+/* Configuration */
+typedef struct _meshtastic_Config_DeviceConfig {
+    /* Sets the role of node */
+    meshtastic_Config_DeviceConfig_Role role;
+    /* Disabling this will disable the SerialConsole by not initilizing the StreamAPI */
+    bool serial_enabled;
+    /* By default we turn off logging as soon as an API client connects (to keep shared serial link quiet).
+ Set this to true to leave the debug log outputting even when API is active. */
+    bool debug_log_enabled;
+    /* For boards without a hard wired button, this is the pin number that will be used
+ Boards that have more than one button can swap the function with this one. defaults to BUTTON_PIN if defined. */
+    uint32_t button_gpio;
+    /* For boards without a PWM buzzer, this is the pin number that will be used
+ Defaults to PIN_BUZZER if defined. */
+    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;
+    /* Treat double tap interrupt on supported accelerometers as a button press if set to true */
+    bool double_tap_as_button_press;
+    /* If true, device is considered to be "managed" by a mesh administrator
+ Clients should then limit available configuration and administrative options inside the user interface */
+    bool is_managed;
+    /* Disables the triple-press of user button to enable or disable GPS */
+    bool disable_triple_click;
+    /* POSIX Timezone definition string from https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv. */
+    char tzdef[65];
+} meshtastic_Config_DeviceConfig;
+
+/* Position Config */
+typedef struct _meshtastic_Config_PositionConfig {
+    /* We should send our position this often (but only if it has changed significantly)
+ Defaults to 15 minutes */
+    uint32_t position_broadcast_secs;
+    /* Adaptive position braoadcast, which is now the default. */
+    bool position_broadcast_smart_enabled;
+    /* If set, this node is at a fixed position.
+ We will generate GPS position updates at the regular interval, but use whatever the last lat/lon/alt we have for the node.
+ The lat/lon/alt can be set by an internal GPS or with the help of the app. */
+    bool fixed_position;
+    /* Is GPS enabled for this node? */
+    bool gps_enabled;
+    /* How often should we try to get GPS position (in seconds)
+ or zero for the default of once every 30 seconds
+ or a very large value (maxint) to update only once at boot. */
+    uint32_t gps_update_interval;
+    /* Deprecated in favor of using smart / regular broadcast intervals as implicit attempt time */
+    uint32_t gps_attempt_time;
+    /* Bit field of boolean configuration options for POSITION messages
+ (bitwise OR of PositionFlags) */
+    uint32_t position_flags;
+    /* (Re)define GPS_RX_PIN for your board. */
+    uint32_t rx_gpio;
+    /* (Re)define GPS_TX_PIN for your board. */
+    uint32_t tx_gpio;
+    /* The minimum distance in meters traveled (since the last send) before we can send a position to the mesh if position_broadcast_smart_enabled */
+    uint32_t broadcast_smart_minimum_distance;
+    /* The minimum number of seconds (since the last send) before we can send a position to the mesh if position_broadcast_smart_enabled */
+    uint32_t broadcast_smart_minimum_interval_secs;
+    /* (Re)define PIN_GPS_EN for your board. */
+    uint32_t gps_en_gpio;
+    /* Set where GPS is enabled, disabled, or not present */
+    meshtastic_Config_PositionConfig_GpsMode gps_mode;
+} meshtastic_Config_PositionConfig;
+
+/* Power Config\
+ See [Power Config](/docs/settings/config/power) for additional power config details. */
+typedef struct _meshtastic_Config_PowerConfig {
+    /* If set, we are powered from a low-current source (i.e. solar), so even if it looks like we have power flowing in
+ we should try to minimize power consumption as much as possible.
+ YOU DO NOT NEED TO SET THIS IF YOU'VE set is_router (it is implied in that case).
+ Advanced Option */
+    bool is_power_saving;
+    /* If non-zero, the device will fully power off this many seconds after external power is removed. */
+    uint32_t on_battery_shutdown_after_secs;
+    /* Ratio of voltage divider for battery pin eg. 3.20 (R1=100k, R2=220k)
+ Overrides the ADC_MULTIPLIER defined in variant for battery voltage calculation.
+ Should be set to floating point value between 2 and 4
+ Fixes issues on Heltec v2 */
+    float adc_multiplier_override;
+    /* Wait Bluetooth Seconds
+ The number of seconds for to wait before turning off BLE in No Bluetooth states
+ 0 for default of 1 minute */
+    uint32_t wait_bluetooth_secs;
+    /* Super Deep Sleep Seconds
+ While in Light Sleep if mesh_sds_timeout_secs is exceeded we will lower into super deep sleep
+ for this value (default 1 year) or a button press
+ 0 for default of one year */
+    uint32_t sds_secs;
+    /* Light Sleep Seconds
+ In light sleep the CPU is suspended, LoRa radio is on, BLE is off an GPS is on
+ ESP32 Only
+ 0 for default of 300 */
+    uint32_t ls_secs;
+    /* Minimum Wake Seconds
+ While in light sleep when we receive packets on the LoRa radio we will wake and handle them and stay awake in no BLE mode for this value
+ 0 for default of 10 seconds */
+    uint32_t min_wake_secs;
+    /* I2C address of INA_2XX to use for reading device battery voltage */
+    uint8_t device_battery_ina_address;
+} meshtastic_Config_PowerConfig;
+
+typedef struct _meshtastic_Config_NetworkConfig_IpV4Config {
+    /* Static IP address */
+    uint32_t ip;
+    /* Static gateway address */
+    uint32_t gateway;
+    /* Static subnet mask */
+    uint32_t subnet;
+    /* Static DNS server address */
+    uint32_t dns;
+} meshtastic_Config_NetworkConfig_IpV4Config;
+
+/* Network Config */
+typedef struct _meshtastic_Config_NetworkConfig {
+    /* Enable WiFi (disables Bluetooth) */
+    bool wifi_enabled;
+    /* If set, this node will try to join the specified wifi network and
+ acquire an address via DHCP */
+    char wifi_ssid[33];
+    /* If set, will be use to authenticate to the named wifi */
+    char wifi_psk[65];
+    /* NTP server to use if WiFi is conneced, defaults to `0.pool.ntp.org` */
+    char ntp_server[33];
+    /* Enable Ethernet */
+    bool eth_enabled;
+    /* acquire an address via DHCP or assign static */
+    meshtastic_Config_NetworkConfig_AddressMode address_mode;
+    /* struct to keep static address */
+    bool has_ipv4_config;
+    meshtastic_Config_NetworkConfig_IpV4Config ipv4_config;
+    /* rsyslog Server and Port */
+    char rsyslog_server[33];
+} meshtastic_Config_NetworkConfig;
+
+/* Display Config */
+typedef struct _meshtastic_Config_DisplayConfig {
+    /* Number of seconds the screen stays on after pressing the user button or receiving a message
+ 0 for default of one minute MAXUINT for always on */
+    uint32_t screen_on_secs;
+    /* How the GPS coordinates are formatted on the OLED screen. */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat gps_format;
+    /* Automatically toggles to the next page on the screen like a carousel, based the specified interval in seconds.
+ Potentially useful for devices without user buttons. */
+    uint32_t auto_screen_carousel_secs;
+    /* If this is set, the displayed compass will always point north. if unset, the old behaviour
+ (top of display is heading direction) is used. */
+    bool compass_north_top;
+    /* Flip screen vertically, for cases that mount the screen upside down */
+    bool flip_screen;
+    /* Perferred display units */
+    meshtastic_Config_DisplayConfig_DisplayUnits units;
+    /* Override auto-detect in screen */
+    meshtastic_Config_DisplayConfig_OledType oled;
+    /* Display Mode */
+    meshtastic_Config_DisplayConfig_DisplayMode displaymode;
+    /* Print first line in pseudo-bold? FALSE is original style, TRUE is bold */
+    bool heading_bold;
+    /* Should we wake the screen up on accelerometer detected motion or tap */
+    bool wake_on_tap_or_motion;
+} meshtastic_Config_DisplayConfig;
+
+/* Lora Config */
+typedef struct _meshtastic_Config_LoRaConfig {
+    /* When enabled, the `modem_preset` fields will be adhered to, else the `bandwidth`/`spread_factor`/`coding_rate`
+ will be taked from their respective manually defined fields */
+    bool use_preset;
+    /* Either modem_config or bandwidth/spreading/coding will be specified - NOT BOTH.
+ As a heuristic: If bandwidth is specified, do not use modem_config.
+ Because protobufs take ZERO space when the value is zero this works out nicely.
+ This value is replaced by bandwidth/spread_factor/coding_rate.
+ If you'd like to experiment with other options add them to MeshRadio.cpp in the device code. */
+    meshtastic_Config_LoRaConfig_ModemPreset modem_preset;
+    /* Bandwidth in MHz
+ Certain bandwidth numbers are 'special' and will be converted to the
+ appropriate floating point value: 31 -> 31.25MHz */
+    uint16_t bandwidth;
+    /* A number from 7 to 12.
+ Indicates number of chirps per symbol as 1<<spread_factor. */
+    uint32_t spread_factor;
+    /* The denominator of the coding rate.
+ ie for 4/5, the value is 5. 4/8 the value is 8. */
+    uint8_t coding_rate;
+    /* This parameter is for advanced users with advanced test equipment, we do not recommend most users use it.
+ A frequency offset that is added to to the calculated band center frequency.
+ Used to correct for crystal calibration errors. */
+    float frequency_offset;
+    /* The region code for the radio (US, CN, EU433, etc...) */
+    meshtastic_Config_LoRaConfig_RegionCode region;
+    /* Maximum number of hops. This can't be greater than 7.
+ Default of 3
+ Attempting to set a value > 7 results in the default */
+    uint32_t hop_limit;
+    /* Disable TX from the LoRa radio. Useful for hot-swapping antennas and other tests.
+ Defaults to false */
+    bool tx_enabled;
+    /* If zero, then use default max legal continuous power (ie. something that won't
+ burn out the radio hardware)
+ In most cases you should use zero here.
+ Units are in dBm. */
+    int8_t tx_power;
+    /* This controls the actual hardware frequency the radio transmits on.
+ Most users should never need to be exposed to this field/concept.
+ A channel number between 1 and NUM_CHANNELS (whatever the max is in the current region).
+ If ZERO then the rule is "use the old channel name hash based
+ algorithm to derive the channel number")
+ If using the hash algorithm the channel number will be: hash(channel_name) %
+ NUM_CHANNELS (Where num channels depends on the regulatory region). */
+    uint16_t channel_num;
+    /* If true, duty cycle limits will be exceeded and thus you're possibly not following
+ the local regulations if you're not a HAM.
+ Has no effect if the duty cycle of the used region is 100%. */
+    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 dropped on receive (by router.cpp) */
+    pb_size_t ignore_incoming_count;
+    uint32_t ignore_incoming[3];
+    /* If true, the device will not process any packets received via LoRa that passed via MQTT anywhere on the path towards it. */
+    bool ignore_mqtt;
+} meshtastic_Config_LoRaConfig;
+
+typedef struct _meshtastic_Config_BluetoothConfig {
+    /* Enable Bluetooth on the device */
+    bool enabled;
+    /* Determines the pairing strategy for the device */
+    meshtastic_Config_BluetoothConfig_PairingMode mode;
+    /* Specified PIN for PairingMode.FixedPin */
+    uint32_t fixed_pin;
+} meshtastic_Config_BluetoothConfig;
+
+typedef struct _meshtastic_Config {
+    pb_size_t which_payload_variant;
+    union {
+        meshtastic_Config_DeviceConfig device;
+        meshtastic_Config_PositionConfig position;
+        meshtastic_Config_PowerConfig power;
+        meshtastic_Config_NetworkConfig network;
+        meshtastic_Config_DisplayConfig display;
+        meshtastic_Config_LoRaConfig lora;
+        meshtastic_Config_BluetoothConfig bluetooth;
+    } payload_variant;
+} meshtastic_Config;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* 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_TAK_TRACKER
+#define _meshtastic_Config_DeviceConfig_Role_ARRAYSIZE ((meshtastic_Config_DeviceConfig_Role)(meshtastic_Config_DeviceConfig_Role_TAK_TRACKER+1))
+
+#define _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN meshtastic_Config_DeviceConfig_RebroadcastMode_ALL
+#define _meshtastic_Config_DeviceConfig_RebroadcastMode_MAX meshtastic_Config_DeviceConfig_RebroadcastMode_KNOWN_ONLY
+#define _meshtastic_Config_DeviceConfig_RebroadcastMode_ARRAYSIZE ((meshtastic_Config_DeviceConfig_RebroadcastMode)(meshtastic_Config_DeviceConfig_RebroadcastMode_KNOWN_ONLY+1))
+
+#define _meshtastic_Config_PositionConfig_PositionFlags_MIN meshtastic_Config_PositionConfig_PositionFlags_UNSET
+#define _meshtastic_Config_PositionConfig_PositionFlags_MAX meshtastic_Config_PositionConfig_PositionFlags_SPEED
+#define _meshtastic_Config_PositionConfig_PositionFlags_ARRAYSIZE ((meshtastic_Config_PositionConfig_PositionFlags)(meshtastic_Config_PositionConfig_PositionFlags_SPEED+1))
+
+#define _meshtastic_Config_PositionConfig_GpsMode_MIN meshtastic_Config_PositionConfig_GpsMode_DISABLED
+#define _meshtastic_Config_PositionConfig_GpsMode_MAX meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT
+#define _meshtastic_Config_PositionConfig_GpsMode_ARRAYSIZE ((meshtastic_Config_PositionConfig_GpsMode)(meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT+1))
+
+#define _meshtastic_Config_NetworkConfig_AddressMode_MIN meshtastic_Config_NetworkConfig_AddressMode_DHCP
+#define _meshtastic_Config_NetworkConfig_AddressMode_MAX meshtastic_Config_NetworkConfig_AddressMode_STATIC
+#define _meshtastic_Config_NetworkConfig_AddressMode_ARRAYSIZE ((meshtastic_Config_NetworkConfig_AddressMode)(meshtastic_Config_NetworkConfig_AddressMode_STATIC+1))
+
+#define _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN meshtastic_Config_DisplayConfig_GpsCoordinateFormat_DEC
+#define _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MAX meshtastic_Config_DisplayConfig_GpsCoordinateFormat_OSGR
+#define _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_ARRAYSIZE ((meshtastic_Config_DisplayConfig_GpsCoordinateFormat)(meshtastic_Config_DisplayConfig_GpsCoordinateFormat_OSGR+1))
+
+#define _meshtastic_Config_DisplayConfig_DisplayUnits_MIN meshtastic_Config_DisplayConfig_DisplayUnits_METRIC
+#define _meshtastic_Config_DisplayConfig_DisplayUnits_MAX meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL
+#define _meshtastic_Config_DisplayConfig_DisplayUnits_ARRAYSIZE ((meshtastic_Config_DisplayConfig_DisplayUnits)(meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL+1))
+
+#define _meshtastic_Config_DisplayConfig_OledType_MIN meshtastic_Config_DisplayConfig_OledType_OLED_AUTO
+#define _meshtastic_Config_DisplayConfig_OledType_MAX meshtastic_Config_DisplayConfig_OledType_OLED_SH1107
+#define _meshtastic_Config_DisplayConfig_OledType_ARRAYSIZE ((meshtastic_Config_DisplayConfig_OledType)(meshtastic_Config_DisplayConfig_OledType_OLED_SH1107+1))
+
+#define _meshtastic_Config_DisplayConfig_DisplayMode_MIN meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT
+#define _meshtastic_Config_DisplayConfig_DisplayMode_MAX meshtastic_Config_DisplayConfig_DisplayMode_COLOR
+#define _meshtastic_Config_DisplayConfig_DisplayMode_ARRAYSIZE ((meshtastic_Config_DisplayConfig_DisplayMode)(meshtastic_Config_DisplayConfig_DisplayMode_COLOR+1))
+
+#define _meshtastic_Config_LoRaConfig_RegionCode_MIN meshtastic_Config_LoRaConfig_RegionCode_UNSET
+#define _meshtastic_Config_LoRaConfig_RegionCode_MAX meshtastic_Config_LoRaConfig_RegionCode_SG_923
+#define _meshtastic_Config_LoRaConfig_RegionCode_ARRAYSIZE ((meshtastic_Config_LoRaConfig_RegionCode)(meshtastic_Config_LoRaConfig_RegionCode_SG_923+1))
+
+#define _meshtastic_Config_LoRaConfig_ModemPreset_MIN meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST
+#define _meshtastic_Config_LoRaConfig_ModemPreset_MAX meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE
+#define _meshtastic_Config_LoRaConfig_ModemPreset_ARRAYSIZE ((meshtastic_Config_LoRaConfig_ModemPreset)(meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE+1))
+
+#define _meshtastic_Config_BluetoothConfig_PairingMode_MIN meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN
+#define _meshtastic_Config_BluetoothConfig_PairingMode_MAX meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN
+#define _meshtastic_Config_BluetoothConfig_PairingMode_ARRAYSIZE ((meshtastic_Config_BluetoothConfig_PairingMode)(meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN+1))
+
+
+#define meshtastic_Config_DeviceConfig_role_ENUMTYPE meshtastic_Config_DeviceConfig_Role
+#define meshtastic_Config_DeviceConfig_rebroadcast_mode_ENUMTYPE meshtastic_Config_DeviceConfig_RebroadcastMode
+
+#define meshtastic_Config_PositionConfig_gps_mode_ENUMTYPE meshtastic_Config_PositionConfig_GpsMode
+
+
+#define meshtastic_Config_NetworkConfig_address_mode_ENUMTYPE meshtastic_Config_NetworkConfig_AddressMode
+
+
+#define meshtastic_Config_DisplayConfig_gps_format_ENUMTYPE meshtastic_Config_DisplayConfig_GpsCoordinateFormat
+#define meshtastic_Config_DisplayConfig_units_ENUMTYPE meshtastic_Config_DisplayConfig_DisplayUnits
+#define meshtastic_Config_DisplayConfig_oled_ENUMTYPE meshtastic_Config_DisplayConfig_OledType
+#define meshtastic_Config_DisplayConfig_displaymode_ENUMTYPE meshtastic_Config_DisplayConfig_DisplayMode
+
+#define meshtastic_Config_LoRaConfig_modem_preset_ENUMTYPE meshtastic_Config_LoRaConfig_ModemPreset
+#define meshtastic_Config_LoRaConfig_region_ENUMTYPE meshtastic_Config_LoRaConfig_RegionCode
+
+#define meshtastic_Config_BluetoothConfig_mode_ENUMTYPE meshtastic_Config_BluetoothConfig_PairingMode
+
+
+/* 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, 0, 0, 0, 0, ""}
+#define meshtastic_Config_PositionConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _meshtastic_Config_PositionConfig_GpsMode_MIN}
+#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, 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}, 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, 0, 0, 0, 0, ""}
+#define meshtastic_Config_PositionConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _meshtastic_Config_PositionConfig_GpsMode_MIN}
+#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, 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}, 0}
+#define meshtastic_Config_BluetoothConfig_init_zero {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_Config_DeviceConfig_role_tag  1
+#define meshtastic_Config_DeviceConfig_serial_enabled_tag 2
+#define meshtastic_Config_DeviceConfig_debug_log_enabled_tag 3
+#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_DeviceConfig_double_tap_as_button_press_tag 8
+#define meshtastic_Config_DeviceConfig_is_managed_tag 9
+#define meshtastic_Config_DeviceConfig_disable_triple_click_tag 10
+#define meshtastic_Config_DeviceConfig_tzdef_tag 11
+#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
+#define meshtastic_Config_PositionConfig_gps_enabled_tag 4
+#define meshtastic_Config_PositionConfig_gps_update_interval_tag 5
+#define meshtastic_Config_PositionConfig_gps_attempt_time_tag 6
+#define meshtastic_Config_PositionConfig_position_flags_tag 7
+#define meshtastic_Config_PositionConfig_rx_gpio_tag 8
+#define meshtastic_Config_PositionConfig_tx_gpio_tag 9
+#define meshtastic_Config_PositionConfig_broadcast_smart_minimum_distance_tag 10
+#define meshtastic_Config_PositionConfig_broadcast_smart_minimum_interval_secs_tag 11
+#define meshtastic_Config_PositionConfig_gps_en_gpio_tag 12
+#define meshtastic_Config_PositionConfig_gps_mode_tag 13
+#define meshtastic_Config_PowerConfig_is_power_saving_tag 1
+#define meshtastic_Config_PowerConfig_on_battery_shutdown_after_secs_tag 2
+#define meshtastic_Config_PowerConfig_adc_multiplier_override_tag 3
+#define meshtastic_Config_PowerConfig_wait_bluetooth_secs_tag 4
+#define meshtastic_Config_PowerConfig_sds_secs_tag 6
+#define meshtastic_Config_PowerConfig_ls_secs_tag 7
+#define meshtastic_Config_PowerConfig_min_wake_secs_tag 8
+#define meshtastic_Config_PowerConfig_device_battery_ina_address_tag 9
+#define meshtastic_Config_NetworkConfig_IpV4Config_ip_tag 1
+#define meshtastic_Config_NetworkConfig_IpV4Config_gateway_tag 2
+#define meshtastic_Config_NetworkConfig_IpV4Config_subnet_tag 3
+#define meshtastic_Config_NetworkConfig_IpV4Config_dns_tag 4
+#define meshtastic_Config_NetworkConfig_wifi_enabled_tag 1
+#define meshtastic_Config_NetworkConfig_wifi_ssid_tag 3
+#define meshtastic_Config_NetworkConfig_wifi_psk_tag 4
+#define meshtastic_Config_NetworkConfig_ntp_server_tag 5
+#define meshtastic_Config_NetworkConfig_eth_enabled_tag 6
+#define meshtastic_Config_NetworkConfig_address_mode_tag 7
+#define meshtastic_Config_NetworkConfig_ipv4_config_tag 8
+#define meshtastic_Config_NetworkConfig_rsyslog_server_tag 9
+#define meshtastic_Config_DisplayConfig_screen_on_secs_tag 1
+#define meshtastic_Config_DisplayConfig_gps_format_tag 2
+#define meshtastic_Config_DisplayConfig_auto_screen_carousel_secs_tag 3
+#define meshtastic_Config_DisplayConfig_compass_north_top_tag 4
+#define meshtastic_Config_DisplayConfig_flip_screen_tag 5
+#define meshtastic_Config_DisplayConfig_units_tag 6
+#define meshtastic_Config_DisplayConfig_oled_tag 7
+#define meshtastic_Config_DisplayConfig_displaymode_tag 8
+#define meshtastic_Config_DisplayConfig_heading_bold_tag 9
+#define meshtastic_Config_DisplayConfig_wake_on_tap_or_motion_tag 10
+#define meshtastic_Config_LoRaConfig_use_preset_tag 1
+#define meshtastic_Config_LoRaConfig_modem_preset_tag 2
+#define meshtastic_Config_LoRaConfig_bandwidth_tag 3
+#define meshtastic_Config_LoRaConfig_spread_factor_tag 4
+#define meshtastic_Config_LoRaConfig_coding_rate_tag 5
+#define meshtastic_Config_LoRaConfig_frequency_offset_tag 6
+#define meshtastic_Config_LoRaConfig_region_tag  7
+#define meshtastic_Config_LoRaConfig_hop_limit_tag 8
+#define meshtastic_Config_LoRaConfig_tx_enabled_tag 9
+#define meshtastic_Config_LoRaConfig_tx_power_tag 10
+#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_LoRaConfig_ignore_mqtt_tag 104
+#define meshtastic_Config_BluetoothConfig_enabled_tag 1
+#define meshtastic_Config_BluetoothConfig_mode_tag 2
+#define meshtastic_Config_BluetoothConfig_fixed_pin_tag 3
+#define meshtastic_Config_device_tag             1
+#define meshtastic_Config_position_tag           2
+#define meshtastic_Config_power_tag              3
+#define meshtastic_Config_network_tag            4
+#define meshtastic_Config_display_tag            5
+#define meshtastic_Config_lora_tag               6
+#define meshtastic_Config_bluetooth_tag          7
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_Config_FIELDLIST(X, a) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,device,payload_variant.device),   1) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,position,payload_variant.position),   2) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,power,payload_variant.power),   3) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,network,payload_variant.network),   4) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,display,payload_variant.display),   5) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,lora,payload_variant.lora),   6) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,bluetooth,payload_variant.bluetooth),   7)
+#define meshtastic_Config_CALLBACK NULL
+#define meshtastic_Config_DEFAULT NULL
+#define meshtastic_Config_payload_variant_device_MSGTYPE meshtastic_Config_DeviceConfig
+#define meshtastic_Config_payload_variant_position_MSGTYPE meshtastic_Config_PositionConfig
+#define meshtastic_Config_payload_variant_power_MSGTYPE meshtastic_Config_PowerConfig
+#define meshtastic_Config_payload_variant_network_MSGTYPE meshtastic_Config_NetworkConfig
+#define meshtastic_Config_payload_variant_display_MSGTYPE meshtastic_Config_DisplayConfig
+#define meshtastic_Config_payload_variant_lora_MSGTYPE meshtastic_Config_LoRaConfig
+#define meshtastic_Config_payload_variant_bluetooth_MSGTYPE meshtastic_Config_BluetoothConfig
+
+#define meshtastic_Config_DeviceConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    role,              1) \
+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, UINT32,   node_info_broadcast_secs,   7) \
+X(a, STATIC,   SINGULAR, BOOL,     double_tap_as_button_press,   8) \
+X(a, STATIC,   SINGULAR, BOOL,     is_managed,        9) \
+X(a, STATIC,   SINGULAR, BOOL,     disable_triple_click,  10) \
+X(a, STATIC,   SINGULAR, STRING,   tzdef,            11)
+#define meshtastic_Config_DeviceConfig_CALLBACK NULL
+#define meshtastic_Config_DeviceConfig_DEFAULT NULL
+
+#define meshtastic_Config_PositionConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   position_broadcast_secs,   1) \
+X(a, STATIC,   SINGULAR, BOOL,     position_broadcast_smart_enabled,   2) \
+X(a, STATIC,   SINGULAR, BOOL,     fixed_position,    3) \
+X(a, STATIC,   SINGULAR, BOOL,     gps_enabled,       4) \
+X(a, STATIC,   SINGULAR, UINT32,   gps_update_interval,   5) \
+X(a, STATIC,   SINGULAR, UINT32,   gps_attempt_time,   6) \
+X(a, STATIC,   SINGULAR, UINT32,   position_flags,    7) \
+X(a, STATIC,   SINGULAR, UINT32,   rx_gpio,           8) \
+X(a, STATIC,   SINGULAR, UINT32,   tx_gpio,           9) \
+X(a, STATIC,   SINGULAR, UINT32,   broadcast_smart_minimum_distance,  10) \
+X(a, STATIC,   SINGULAR, UINT32,   broadcast_smart_minimum_interval_secs,  11) \
+X(a, STATIC,   SINGULAR, UINT32,   gps_en_gpio,      12) \
+X(a, STATIC,   SINGULAR, UENUM,    gps_mode,         13)
+#define meshtastic_Config_PositionConfig_CALLBACK NULL
+#define meshtastic_Config_PositionConfig_DEFAULT NULL
+
+#define meshtastic_Config_PowerConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     is_power_saving,   1) \
+X(a, STATIC,   SINGULAR, UINT32,   on_battery_shutdown_after_secs,   2) \
+X(a, STATIC,   SINGULAR, FLOAT,    adc_multiplier_override,   3) \
+X(a, STATIC,   SINGULAR, UINT32,   wait_bluetooth_secs,   4) \
+X(a, STATIC,   SINGULAR, UINT32,   sds_secs,          6) \
+X(a, STATIC,   SINGULAR, UINT32,   ls_secs,           7) \
+X(a, STATIC,   SINGULAR, UINT32,   min_wake_secs,     8) \
+X(a, STATIC,   SINGULAR, UINT32,   device_battery_ina_address,   9)
+#define meshtastic_Config_PowerConfig_CALLBACK NULL
+#define meshtastic_Config_PowerConfig_DEFAULT NULL
+
+#define meshtastic_Config_NetworkConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     wifi_enabled,      1) \
+X(a, STATIC,   SINGULAR, STRING,   wifi_ssid,         3) \
+X(a, STATIC,   SINGULAR, STRING,   wifi_psk,          4) \
+X(a, STATIC,   SINGULAR, STRING,   ntp_server,        5) \
+X(a, STATIC,   SINGULAR, BOOL,     eth_enabled,       6) \
+X(a, STATIC,   SINGULAR, UENUM,    address_mode,      7) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  ipv4_config,       8) \
+X(a, STATIC,   SINGULAR, STRING,   rsyslog_server,    9)
+#define meshtastic_Config_NetworkConfig_CALLBACK NULL
+#define meshtastic_Config_NetworkConfig_DEFAULT NULL
+#define meshtastic_Config_NetworkConfig_ipv4_config_MSGTYPE meshtastic_Config_NetworkConfig_IpV4Config
+
+#define meshtastic_Config_NetworkConfig_IpV4Config_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, FIXED32,  ip,                1) \
+X(a, STATIC,   SINGULAR, FIXED32,  gateway,           2) \
+X(a, STATIC,   SINGULAR, FIXED32,  subnet,            3) \
+X(a, STATIC,   SINGULAR, FIXED32,  dns,               4)
+#define meshtastic_Config_NetworkConfig_IpV4Config_CALLBACK NULL
+#define meshtastic_Config_NetworkConfig_IpV4Config_DEFAULT NULL
+
+#define meshtastic_Config_DisplayConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   screen_on_secs,    1) \
+X(a, STATIC,   SINGULAR, UENUM,    gps_format,        2) \
+X(a, STATIC,   SINGULAR, UINT32,   auto_screen_carousel_secs,   3) \
+X(a, STATIC,   SINGULAR, BOOL,     compass_north_top,   4) \
+X(a, STATIC,   SINGULAR, BOOL,     flip_screen,       5) \
+X(a, STATIC,   SINGULAR, UENUM,    units,             6) \
+X(a, STATIC,   SINGULAR, UENUM,    oled,              7) \
+X(a, STATIC,   SINGULAR, UENUM,    displaymode,       8) \
+X(a, STATIC,   SINGULAR, BOOL,     heading_bold,      9) \
+X(a, STATIC,   SINGULAR, BOOL,     wake_on_tap_or_motion,  10)
+#define meshtastic_Config_DisplayConfig_CALLBACK NULL
+#define meshtastic_Config_DisplayConfig_DEFAULT NULL
+
+#define meshtastic_Config_LoRaConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     use_preset,        1) \
+X(a, STATIC,   SINGULAR, UENUM,    modem_preset,      2) \
+X(a, STATIC,   SINGULAR, UINT32,   bandwidth,         3) \
+X(a, STATIC,   SINGULAR, UINT32,   spread_factor,     4) \
+X(a, STATIC,   SINGULAR, UINT32,   coding_rate,       5) \
+X(a, STATIC,   SINGULAR, FLOAT,    frequency_offset,   6) \
+X(a, STATIC,   SINGULAR, UENUM,    region,            7) \
+X(a, STATIC,   SINGULAR, UINT32,   hop_limit,         8) \
+X(a, STATIC,   SINGULAR, BOOL,     tx_enabled,        9) \
+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) \
+X(a, STATIC,   SINGULAR, BOOL,     ignore_mqtt,     104)
+#define meshtastic_Config_LoRaConfig_CALLBACK NULL
+#define meshtastic_Config_LoRaConfig_DEFAULT NULL
+
+#define meshtastic_Config_BluetoothConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
+X(a, STATIC,   SINGULAR, UENUM,    mode,              2) \
+X(a, STATIC,   SINGULAR, UINT32,   fixed_pin,         3)
+#define meshtastic_Config_BluetoothConfig_CALLBACK NULL
+#define meshtastic_Config_BluetoothConfig_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_Config_msg;
+extern const pb_msgdesc_t meshtastic_Config_DeviceConfig_msg;
+extern const pb_msgdesc_t meshtastic_Config_PositionConfig_msg;
+extern const pb_msgdesc_t meshtastic_Config_PowerConfig_msg;
+extern const pb_msgdesc_t meshtastic_Config_NetworkConfig_msg;
+extern const pb_msgdesc_t meshtastic_Config_NetworkConfig_IpV4Config_msg;
+extern const pb_msgdesc_t meshtastic_Config_DisplayConfig_msg;
+extern const pb_msgdesc_t meshtastic_Config_LoRaConfig_msg;
+extern const pb_msgdesc_t meshtastic_Config_BluetoothConfig_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_Config_fields &meshtastic_Config_msg
+#define meshtastic_Config_DeviceConfig_fields &meshtastic_Config_DeviceConfig_msg
+#define meshtastic_Config_PositionConfig_fields &meshtastic_Config_PositionConfig_msg
+#define meshtastic_Config_PowerConfig_fields &meshtastic_Config_PowerConfig_msg
+#define meshtastic_Config_NetworkConfig_fields &meshtastic_Config_NetworkConfig_msg
+#define meshtastic_Config_NetworkConfig_IpV4Config_fields &meshtastic_Config_NetworkConfig_IpV4Config_msg
+#define meshtastic_Config_DisplayConfig_fields &meshtastic_Config_DisplayConfig_msg
+#define meshtastic_Config_LoRaConfig_fields &meshtastic_Config_LoRaConfig_msg
+#define meshtastic_Config_BluetoothConfig_fields &meshtastic_Config_BluetoothConfig_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_CONFIG_PB_H_MAX_SIZE meshtastic_Config_size
+#define meshtastic_Config_BluetoothConfig_size   10
+#define meshtastic_Config_DeviceConfig_size      98
+#define meshtastic_Config_DisplayConfig_size     28
+#define meshtastic_Config_LoRaConfig_size        80
+#define meshtastic_Config_NetworkConfig_IpV4Config_size 20
+#define meshtastic_Config_NetworkConfig_size     196
+#define meshtastic_Config_PositionConfig_size    62
+#define meshtastic_Config_PowerConfig_size       40
+#define meshtastic_Config_size                   199
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

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

@@ -0,0 +1,27 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#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,190 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#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 {
+    /* 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_MESHTASTIC_CONNECTION_STATUS_PB_H_MAX_SIZE meshtastic_DeviceConnectionStatus_size
+#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/deviceonly.pb.cpp

@@ -0,0 +1,25 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#include "meshtastic/deviceonly.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_PositionLite, meshtastic_PositionLite, AUTO)
+
+
+PB_BIND(meshtastic_NodeInfoLite, meshtastic_NodeInfoLite, AUTO)
+
+
+PB_BIND(meshtastic_DeviceState, meshtastic_DeviceState, 2)
+
+
+PB_BIND(meshtastic_ChannelFile, meshtastic_ChannelFile, 2)
+
+
+PB_BIND(meshtastic_OEMStore, meshtastic_OEMStore, 2)
+
+
+
+

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

@@ -0,0 +1,318 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_INCLUDED
+#include <pb.h>
+#include <vector>
+#include "meshtastic/channel.pb.h"
+#include "meshtastic/localonly.pb.h"
+#include "meshtastic/mesh.pb.h"
+#include "meshtastic/module_config.pb.h"
+#include "meshtastic/telemetry.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+/* Font sizes for the device screen */
+typedef enum _meshtastic_ScreenFonts {
+    /* TODO: REPLACE */
+    meshtastic_ScreenFonts_FONT_SMALL = 0,
+    /* TODO: REPLACE */
+    meshtastic_ScreenFonts_FONT_MEDIUM = 1,
+    /* TODO: REPLACE */
+    meshtastic_ScreenFonts_FONT_LARGE = 2
+} meshtastic_ScreenFonts;
+
+/* Struct definitions */
+/* Position with static location information only for NodeDBLite */
+typedef struct _meshtastic_PositionLite {
+    /* The new preferred location encoding, multiply by 1e-7 to get degrees
+ in floating point */
+    int32_t latitude_i;
+    /* TODO: REPLACE */
+    int32_t longitude_i;
+    /* In meters above MSL (but see issue #359) */
+    int32_t altitude;
+    /* This is usually not sent over the mesh (to save space), but it is sent
+ from the phone so that the local device can set its RTC If it is sent over
+ the mesh (because there are devices on the mesh without GPS), it will only
+ be sent by devices which has a hardware GPS clock.
+ seconds since 1970 */
+    uint32_t time;
+    /* TODO: REPLACE */
+    meshtastic_Position_LocSource location_source;
+} meshtastic_PositionLite;
+
+typedef struct _meshtastic_NodeInfoLite {
+    /* The node number */
+    uint32_t num;
+    /* The user info for this node */
+    bool has_user;
+    meshtastic_User user;
+    /* This position data. Note: before 1.2.14 we would also store the last time we've heard from this node in position.time, that is no longer true.
+ Position.time now indicates the last time we received a POSITION from that node. */
+    bool has_position;
+    meshtastic_PositionLite position;
+    /* Returns the Signal-to-noise ratio (SNR) of the last received message,
+ as measured by the receiver. Return SNR of the last received message in dB */
+    float snr;
+    /* Set to indicate the last time we received a packet from this node */
+    uint32_t last_heard;
+    /* The latest device metrics for the node. */
+    bool has_device_metrics;
+    meshtastic_DeviceMetrics device_metrics;
+    /* local channel index we heard that node on. Only populated if its not the default channel. */
+    uint8_t channel;
+    /* True if we witnessed the node over MQTT instead of LoRA transport */
+    bool via_mqtt;
+    /* Number of hops away from us this node is (0 if adjacent) */
+    uint8_t hops_away;
+    /* True if node is in our favorites list
+ Persists between NodeDB internal clean ups */
+    bool is_favorite;
+} meshtastic_NodeInfoLite;
+
+/* This message is never sent over the wire, but it is used for serializing DB
+ state to flash in the device code
+ FIXME, since we write this each time we enter deep sleep (and have infinite
+ flash) it would be better to use some sort of append only data structure for
+ the receive queue and use the preferences store for the other stuff */
+typedef struct _meshtastic_DeviceState {
+    /* Read only settings/info about this node */
+    bool has_my_node;
+    meshtastic_MyNodeInfo my_node;
+    /* My owner info */
+    bool has_owner;
+    meshtastic_User owner;
+    /* Received packets saved for delivery to the phone */
+    pb_size_t receive_queue_count;
+    meshtastic_MeshPacket receive_queue[1];
+    /* We keep the last received text message (only) stored in the device flash,
+ so we can show it on the screen.
+ Might be null */
+    bool has_rx_text_message;
+    meshtastic_MeshPacket rx_text_message;
+    /* A version integer used to invalidate old save files when we make
+ incompatible changes This integer is set at build time and is private to
+ NodeDB.cpp in the device code. */
+    uint32_t version;
+    /* Used only during development.
+ Indicates developer is testing and changes should never be saved to flash.
+ Deprecated in 2.3.1 */
+    bool no_save;
+    /* Some GPS receivers seem to have bogus settings from the factory, so we always do one factory reset. */
+    bool did_gps_reset;
+    /* We keep the last received waypoint stored in the device flash,
+ so we can show it on the screen.
+ Might be null */
+    bool has_rx_waypoint;
+    meshtastic_MeshPacket rx_waypoint;
+    /* The mesh's nodes with their available gpio pins for RemoteHardware module */
+    pb_size_t node_remote_hardware_pins_count;
+    meshtastic_NodeRemoteHardwarePin node_remote_hardware_pins[12];
+    /* New lite version of NodeDB to decrease memory footprint */
+    std::vector<meshtastic_NodeInfoLite> node_db_lite;
+} meshtastic_DeviceState;
+
+/* The on-disk saved channels */
+typedef struct _meshtastic_ChannelFile {
+    /* The channels our node knows about */
+    pb_size_t channels_count;
+    meshtastic_Channel channels[8];
+    /* A version integer used to invalidate old save files when we make
+ incompatible changes This integer is set at build time and is private to
+ NodeDB.cpp in the device code. */
+    uint32_t version;
+} meshtastic_ChannelFile;
+
+typedef PB_BYTES_ARRAY_T(2048) meshtastic_OEMStore_oem_icon_bits_t;
+typedef PB_BYTES_ARRAY_T(32) meshtastic_OEMStore_oem_aes_key_t;
+/* This can be used for customizing the firmware distribution. If populated,
+ show a secondary bootup screen with custom logo and text for 2.5 seconds. */
+typedef struct _meshtastic_OEMStore {
+    /* The Logo width in Px */
+    uint32_t oem_icon_width;
+    /* The Logo height in Px */
+    uint32_t oem_icon_height;
+    /* The Logo in XBM bytechar format */
+    meshtastic_OEMStore_oem_icon_bits_t oem_icon_bits;
+    /* Use this font for the OEM text. */
+    meshtastic_ScreenFonts oem_font;
+    /* Use this font for the OEM text. */
+    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;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_ScreenFonts_MIN meshtastic_ScreenFonts_FONT_SMALL
+#define _meshtastic_ScreenFonts_MAX meshtastic_ScreenFonts_FONT_LARGE
+#define _meshtastic_ScreenFonts_ARRAYSIZE ((meshtastic_ScreenFonts)(meshtastic_ScreenFonts_FONT_LARGE+1))
+
+#define meshtastic_PositionLite_location_source_ENUMTYPE meshtastic_Position_LocSource
+
+
+
+
+#define meshtastic_OEMStore_oem_font_ENUMTYPE meshtastic_ScreenFonts
+
+
+/* Initializer values for message structs */
+#define meshtastic_PositionLite_init_default     {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
+#define meshtastic_NodeInfoLite_init_default     {0, false, meshtastic_User_init_default, false, meshtastic_PositionLite_init_default, 0, 0, false, meshtastic_DeviceMetrics_init_default, 0, 0, 0, 0}
+#define meshtastic_DeviceState_init_default      {false, meshtastic_MyNodeInfo_init_default, false, meshtastic_User_init_default, 0, {meshtastic_MeshPacket_init_default}, false, meshtastic_MeshPacket_init_default, 0, 0, 0, false, meshtastic_MeshPacket_init_default, 0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}, {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}}, false, meshtastic_LocalConfig_init_default, false, meshtastic_LocalModuleConfig_init_default}
+#define meshtastic_PositionLite_init_zero        {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
+#define meshtastic_NodeInfoLite_init_zero        {0, false, meshtastic_User_init_zero, false, meshtastic_PositionLite_init_zero, 0, 0, false, meshtastic_DeviceMetrics_init_zero, 0, 0, 0, 0}
+#define meshtastic_DeviceState_init_zero         {false, meshtastic_MyNodeInfo_init_zero, false, meshtastic_User_init_zero, 0, {meshtastic_MeshPacket_init_zero}, false, meshtastic_MeshPacket_init_zero, 0, 0, 0, false, meshtastic_MeshPacket_init_zero, 0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}, {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}}, false, meshtastic_LocalConfig_init_zero, false, meshtastic_LocalModuleConfig_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_PositionLite_latitude_i_tag   1
+#define meshtastic_PositionLite_longitude_i_tag  2
+#define meshtastic_PositionLite_altitude_tag     3
+#define meshtastic_PositionLite_time_tag         4
+#define meshtastic_PositionLite_location_source_tag 5
+#define meshtastic_NodeInfoLite_num_tag          1
+#define meshtastic_NodeInfoLite_user_tag         2
+#define meshtastic_NodeInfoLite_position_tag     3
+#define meshtastic_NodeInfoLite_snr_tag          4
+#define meshtastic_NodeInfoLite_last_heard_tag   5
+#define meshtastic_NodeInfoLite_device_metrics_tag 6
+#define meshtastic_NodeInfoLite_channel_tag      7
+#define meshtastic_NodeInfoLite_via_mqtt_tag     8
+#define meshtastic_NodeInfoLite_hops_away_tag    9
+#define meshtastic_NodeInfoLite_is_favorite_tag  10
+#define meshtastic_DeviceState_my_node_tag       2
+#define meshtastic_DeviceState_owner_tag         3
+#define meshtastic_DeviceState_receive_queue_tag 5
+#define meshtastic_DeviceState_rx_text_message_tag 7
+#define meshtastic_DeviceState_version_tag       8
+#define meshtastic_DeviceState_no_save_tag       9
+#define meshtastic_DeviceState_did_gps_reset_tag 11
+#define meshtastic_DeviceState_rx_waypoint_tag   12
+#define meshtastic_DeviceState_node_remote_hardware_pins_tag 13
+#define meshtastic_DeviceState_node_db_lite_tag  14
+#define meshtastic_ChannelFile_channels_tag      1
+#define meshtastic_ChannelFile_version_tag       2
+#define meshtastic_OEMStore_oem_icon_width_tag   1
+#define meshtastic_OEMStore_oem_icon_height_tag  2
+#define meshtastic_OEMStore_oem_icon_bits_tag    3
+#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_PositionLite_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, SFIXED32, latitude_i,        1) \
+X(a, STATIC,   SINGULAR, SFIXED32, longitude_i,       2) \
+X(a, STATIC,   SINGULAR, INT32,    altitude,          3) \
+X(a, STATIC,   SINGULAR, FIXED32,  time,              4) \
+X(a, STATIC,   SINGULAR, UENUM,    location_source,   5)
+#define meshtastic_PositionLite_CALLBACK NULL
+#define meshtastic_PositionLite_DEFAULT NULL
+
+#define meshtastic_NodeInfoLite_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  user,              2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  position,          3) \
+X(a, STATIC,   SINGULAR, FLOAT,    snr,               4) \
+X(a, STATIC,   SINGULAR, FIXED32,  last_heard,        5) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  device_metrics,    6) \
+X(a, STATIC,   SINGULAR, UINT32,   channel,           7) \
+X(a, STATIC,   SINGULAR, BOOL,     via_mqtt,          8) \
+X(a, STATIC,   SINGULAR, UINT32,   hops_away,         9) \
+X(a, STATIC,   SINGULAR, BOOL,     is_favorite,      10)
+#define meshtastic_NodeInfoLite_CALLBACK NULL
+#define meshtastic_NodeInfoLite_DEFAULT NULL
+#define meshtastic_NodeInfoLite_user_MSGTYPE meshtastic_User
+#define meshtastic_NodeInfoLite_position_MSGTYPE meshtastic_PositionLite
+#define meshtastic_NodeInfoLite_device_metrics_MSGTYPE meshtastic_DeviceMetrics
+
+#define meshtastic_DeviceState_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  my_node,           2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  owner,             3) \
+X(a, STATIC,   REPEATED, MESSAGE,  receive_queue,     5) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  rx_text_message,   7) \
+X(a, STATIC,   SINGULAR, UINT32,   version,           8) \
+X(a, STATIC,   SINGULAR, BOOL,     no_save,           9) \
+X(a, STATIC,   SINGULAR, BOOL,     did_gps_reset,    11) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  rx_waypoint,      12) \
+X(a, STATIC,   REPEATED, MESSAGE,  node_remote_hardware_pins,  13) \
+X(a, CALLBACK, REPEATED, MESSAGE,  node_db_lite,     14)
+extern bool meshtastic_DeviceState_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field);
+#define meshtastic_DeviceState_CALLBACK meshtastic_DeviceState_callback
+#define meshtastic_DeviceState_DEFAULT NULL
+#define meshtastic_DeviceState_my_node_MSGTYPE meshtastic_MyNodeInfo
+#define meshtastic_DeviceState_owner_MSGTYPE meshtastic_User
+#define meshtastic_DeviceState_receive_queue_MSGTYPE meshtastic_MeshPacket
+#define meshtastic_DeviceState_rx_text_message_MSGTYPE meshtastic_MeshPacket
+#define meshtastic_DeviceState_rx_waypoint_MSGTYPE meshtastic_MeshPacket
+#define meshtastic_DeviceState_node_remote_hardware_pins_MSGTYPE meshtastic_NodeRemoteHardwarePin
+#define meshtastic_DeviceState_node_db_lite_MSGTYPE meshtastic_NodeInfoLite
+
+#define meshtastic_ChannelFile_FIELDLIST(X, a) \
+X(a, STATIC,   REPEATED, MESSAGE,  channels,          1) \
+X(a, STATIC,   SINGULAR, UINT32,   version,           2)
+#define meshtastic_ChannelFile_CALLBACK NULL
+#define meshtastic_ChannelFile_DEFAULT NULL
+#define meshtastic_ChannelFile_channels_MSGTYPE meshtastic_Channel
+
+#define meshtastic_OEMStore_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   oem_icon_width,    1) \
+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,   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_PositionLite_msg;
+extern const pb_msgdesc_t meshtastic_NodeInfoLite_msg;
+extern const pb_msgdesc_t meshtastic_DeviceState_msg;
+extern const pb_msgdesc_t meshtastic_ChannelFile_msg;
+extern const pb_msgdesc_t meshtastic_OEMStore_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_PositionLite_fields &meshtastic_PositionLite_msg
+#define meshtastic_NodeInfoLite_fields &meshtastic_NodeInfoLite_msg
+#define meshtastic_DeviceState_fields &meshtastic_DeviceState_msg
+#define meshtastic_ChannelFile_fields &meshtastic_ChannelFile_msg
+#define meshtastic_OEMStore_fields &meshtastic_OEMStore_msg
+
+/* Maximum encoded size of messages (where known) */
+/* meshtastic_DeviceState_size depends on runtime parameters */
+#define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_OEMStore_size
+#define meshtastic_ChannelFile_size              702
+#define meshtastic_NodeInfoLite_size             166
+#define meshtastic_OEMStore_size                 3344
+#define meshtastic_PositionLite_size             28
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

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

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#include "meshtastic/localonly.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_LocalConfig, meshtastic_LocalConfig, 2)
+
+
+PB_BIND(meshtastic_LocalModuleConfig, meshtastic_LocalModuleConfig, 2)
+
+
+

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

@@ -0,0 +1,191 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_INCLUDED
+#include <pb.h>
+#include "meshtastic/config.pb.h"
+#include "meshtastic/module_config.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _meshtastic_LocalConfig {
+    /* The part of the config that is specific to the Device */
+    bool has_device;
+    meshtastic_Config_DeviceConfig device;
+    /* The part of the config that is specific to the GPS Position */
+    bool has_position;
+    meshtastic_Config_PositionConfig position;
+    /* The part of the config that is specific to the Power settings */
+    bool has_power;
+    meshtastic_Config_PowerConfig power;
+    /* The part of the config that is specific to the Wifi Settings */
+    bool has_network;
+    meshtastic_Config_NetworkConfig network;
+    /* The part of the config that is specific to the Display */
+    bool has_display;
+    meshtastic_Config_DisplayConfig display;
+    /* The part of the config that is specific to the Lora Radio */
+    bool has_lora;
+    meshtastic_Config_LoRaConfig lora;
+    /* The part of the config that is specific to the Bluetooth settings */
+    bool has_bluetooth;
+    meshtastic_Config_BluetoothConfig bluetooth;
+    /* A version integer used to invalidate old save files when we make
+ incompatible changes This integer is set at build time and is private to
+ NodeDB.cpp in the device code. */
+    uint32_t version;
+} meshtastic_LocalConfig;
+
+typedef struct _meshtastic_LocalModuleConfig {
+    /* The part of the config that is specific to the MQTT module */
+    bool has_mqtt;
+    meshtastic_ModuleConfig_MQTTConfig mqtt;
+    /* The part of the config that is specific to the Serial module */
+    bool has_serial;
+    meshtastic_ModuleConfig_SerialConfig serial;
+    /* The part of the config that is specific to the ExternalNotification module */
+    bool has_external_notification;
+    meshtastic_ModuleConfig_ExternalNotificationConfig external_notification;
+    /* The part of the config that is specific to the Store & Forward module */
+    bool has_store_forward;
+    meshtastic_ModuleConfig_StoreForwardConfig store_forward;
+    /* The part of the config that is specific to the RangeTest module */
+    bool has_range_test;
+    meshtastic_ModuleConfig_RangeTestConfig range_test;
+    /* The part of the config that is specific to the Telemetry module */
+    bool has_telemetry;
+    meshtastic_ModuleConfig_TelemetryConfig telemetry;
+    /* The part of the config that is specific to the Canned Message module */
+    bool has_canned_message;
+    meshtastic_ModuleConfig_CannedMessageConfig canned_message;
+    /* A version integer used to invalidate old save files when we make
+ incompatible changes This integer is set at build time and is private to
+ NodeDB.cpp in the device code. */
+    uint32_t version;
+    /* The part of the config that is specific to the Audio module */
+    bool has_audio;
+    meshtastic_ModuleConfig_AudioConfig audio;
+    /* The part of the config that is specific to the Remote Hardware module */
+    bool has_remote_hardware;
+    meshtastic_ModuleConfig_RemoteHardwareConfig remote_hardware;
+    /* The part of the config that is specific to the Neighbor Info module */
+    bool has_neighbor_info;
+    meshtastic_ModuleConfig_NeighborInfoConfig neighbor_info;
+    /* The part of the config that is specific to the Ambient Lighting module */
+    bool has_ambient_lighting;
+    meshtastic_ModuleConfig_AmbientLightingConfig ambient_lighting;
+    /* The part of the config that is specific to the Detection Sensor module */
+    bool has_detection_sensor;
+    meshtastic_ModuleConfig_DetectionSensorConfig detection_sensor;
+    /* Paxcounter Config */
+    bool has_paxcounter;
+    meshtastic_ModuleConfig_PaxcounterConfig paxcounter;
+} meshtastic_LocalModuleConfig;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define meshtastic_LocalConfig_init_default      {false, meshtastic_Config_DeviceConfig_init_default, false, meshtastic_Config_PositionConfig_init_default, false, meshtastic_Config_PowerConfig_init_default, false, meshtastic_Config_NetworkConfig_init_default, false, meshtastic_Config_DisplayConfig_init_default, false, meshtastic_Config_LoRaConfig_init_default, false, meshtastic_Config_BluetoothConfig_init_default, 0}
+#define meshtastic_LocalModuleConfig_init_default {false, meshtastic_ModuleConfig_MQTTConfig_init_default, false, meshtastic_ModuleConfig_SerialConfig_init_default, false, meshtastic_ModuleConfig_ExternalNotificationConfig_init_default, false, meshtastic_ModuleConfig_StoreForwardConfig_init_default, false, meshtastic_ModuleConfig_RangeTestConfig_init_default, false, meshtastic_ModuleConfig_TelemetryConfig_init_default, false, meshtastic_ModuleConfig_CannedMessageConfig_init_default, 0, false, meshtastic_ModuleConfig_AudioConfig_init_default, false, meshtastic_ModuleConfig_RemoteHardwareConfig_init_default, false, meshtastic_ModuleConfig_NeighborInfoConfig_init_default, false, meshtastic_ModuleConfig_AmbientLightingConfig_init_default, false, meshtastic_ModuleConfig_DetectionSensorConfig_init_default, false, meshtastic_ModuleConfig_PaxcounterConfig_init_default}
+#define meshtastic_LocalConfig_init_zero         {false, meshtastic_Config_DeviceConfig_init_zero, false, meshtastic_Config_PositionConfig_init_zero, false, meshtastic_Config_PowerConfig_init_zero, false, meshtastic_Config_NetworkConfig_init_zero, false, meshtastic_Config_DisplayConfig_init_zero, false, meshtastic_Config_LoRaConfig_init_zero, false, meshtastic_Config_BluetoothConfig_init_zero, 0}
+#define meshtastic_LocalModuleConfig_init_zero   {false, meshtastic_ModuleConfig_MQTTConfig_init_zero, false, meshtastic_ModuleConfig_SerialConfig_init_zero, false, meshtastic_ModuleConfig_ExternalNotificationConfig_init_zero, false, meshtastic_ModuleConfig_StoreForwardConfig_init_zero, false, meshtastic_ModuleConfig_RangeTestConfig_init_zero, false, meshtastic_ModuleConfig_TelemetryConfig_init_zero, false, meshtastic_ModuleConfig_CannedMessageConfig_init_zero, 0, false, meshtastic_ModuleConfig_AudioConfig_init_zero, false, meshtastic_ModuleConfig_RemoteHardwareConfig_init_zero, false, meshtastic_ModuleConfig_NeighborInfoConfig_init_zero, false, meshtastic_ModuleConfig_AmbientLightingConfig_init_zero, false, meshtastic_ModuleConfig_DetectionSensorConfig_init_zero, false, meshtastic_ModuleConfig_PaxcounterConfig_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_LocalConfig_device_tag        1
+#define meshtastic_LocalConfig_position_tag      2
+#define meshtastic_LocalConfig_power_tag         3
+#define meshtastic_LocalConfig_network_tag       4
+#define meshtastic_LocalConfig_display_tag       5
+#define meshtastic_LocalConfig_lora_tag          6
+#define meshtastic_LocalConfig_bluetooth_tag     7
+#define meshtastic_LocalConfig_version_tag       8
+#define meshtastic_LocalModuleConfig_mqtt_tag    1
+#define meshtastic_LocalModuleConfig_serial_tag  2
+#define meshtastic_LocalModuleConfig_external_notification_tag 3
+#define meshtastic_LocalModuleConfig_store_forward_tag 4
+#define meshtastic_LocalModuleConfig_range_test_tag 5
+#define meshtastic_LocalModuleConfig_telemetry_tag 6
+#define meshtastic_LocalModuleConfig_canned_message_tag 7
+#define meshtastic_LocalModuleConfig_version_tag 8
+#define meshtastic_LocalModuleConfig_audio_tag   9
+#define meshtastic_LocalModuleConfig_remote_hardware_tag 10
+#define meshtastic_LocalModuleConfig_neighbor_info_tag 11
+#define meshtastic_LocalModuleConfig_ambient_lighting_tag 12
+#define meshtastic_LocalModuleConfig_detection_sensor_tag 13
+#define meshtastic_LocalModuleConfig_paxcounter_tag 14
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_LocalConfig_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  device,            1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  position,          2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  power,             3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  network,           4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  display,           5) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  lora,              6) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  bluetooth,         7) \
+X(a, STATIC,   SINGULAR, UINT32,   version,           8)
+#define meshtastic_LocalConfig_CALLBACK NULL
+#define meshtastic_LocalConfig_DEFAULT NULL
+#define meshtastic_LocalConfig_device_MSGTYPE meshtastic_Config_DeviceConfig
+#define meshtastic_LocalConfig_position_MSGTYPE meshtastic_Config_PositionConfig
+#define meshtastic_LocalConfig_power_MSGTYPE meshtastic_Config_PowerConfig
+#define meshtastic_LocalConfig_network_MSGTYPE meshtastic_Config_NetworkConfig
+#define meshtastic_LocalConfig_display_MSGTYPE meshtastic_Config_DisplayConfig
+#define meshtastic_LocalConfig_lora_MSGTYPE meshtastic_Config_LoRaConfig
+#define meshtastic_LocalConfig_bluetooth_MSGTYPE meshtastic_Config_BluetoothConfig
+
+#define meshtastic_LocalModuleConfig_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  mqtt,              1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  serial,            2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  external_notification,   3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  store_forward,     4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  range_test,        5) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  telemetry,         6) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  canned_message,    7) \
+X(a, STATIC,   SINGULAR, UINT32,   version,           8) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  audio,             9) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  remote_hardware,  10) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  neighbor_info,    11) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  ambient_lighting,  12) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  detection_sensor,  13) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  paxcounter,       14)
+#define meshtastic_LocalModuleConfig_CALLBACK NULL
+#define meshtastic_LocalModuleConfig_DEFAULT NULL
+#define meshtastic_LocalModuleConfig_mqtt_MSGTYPE meshtastic_ModuleConfig_MQTTConfig
+#define meshtastic_LocalModuleConfig_serial_MSGTYPE meshtastic_ModuleConfig_SerialConfig
+#define meshtastic_LocalModuleConfig_external_notification_MSGTYPE meshtastic_ModuleConfig_ExternalNotificationConfig
+#define meshtastic_LocalModuleConfig_store_forward_MSGTYPE meshtastic_ModuleConfig_StoreForwardConfig
+#define meshtastic_LocalModuleConfig_range_test_MSGTYPE meshtastic_ModuleConfig_RangeTestConfig
+#define meshtastic_LocalModuleConfig_telemetry_MSGTYPE meshtastic_ModuleConfig_TelemetryConfig
+#define meshtastic_LocalModuleConfig_canned_message_MSGTYPE meshtastic_ModuleConfig_CannedMessageConfig
+#define meshtastic_LocalModuleConfig_audio_MSGTYPE meshtastic_ModuleConfig_AudioConfig
+#define meshtastic_LocalModuleConfig_remote_hardware_MSGTYPE meshtastic_ModuleConfig_RemoteHardwareConfig
+#define meshtastic_LocalModuleConfig_neighbor_info_MSGTYPE meshtastic_ModuleConfig_NeighborInfoConfig
+#define meshtastic_LocalModuleConfig_ambient_lighting_MSGTYPE meshtastic_ModuleConfig_AmbientLightingConfig
+#define meshtastic_LocalModuleConfig_detection_sensor_MSGTYPE meshtastic_ModuleConfig_DetectionSensorConfig
+#define meshtastic_LocalModuleConfig_paxcounter_MSGTYPE meshtastic_ModuleConfig_PaxcounterConfig
+
+extern const pb_msgdesc_t meshtastic_LocalConfig_msg;
+extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_LocalConfig_fields &meshtastic_LocalConfig_msg
+#define meshtastic_LocalModuleConfig_fields &meshtastic_LocalModuleConfig_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_MAX_SIZE meshtastic_LocalModuleConfig_size
+#define meshtastic_LocalConfig_size              535
+#define meshtastic_LocalModuleConfig_size        663
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/mesh.pb.cpp

@@ -0,0 +1,78 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#include "meshtastic/mesh.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_Position, meshtastic_Position, AUTO)
+
+
+PB_BIND(meshtastic_User, meshtastic_User, AUTO)
+
+
+PB_BIND(meshtastic_RouteDiscovery, meshtastic_RouteDiscovery, AUTO)
+
+
+PB_BIND(meshtastic_Routing, meshtastic_Routing, AUTO)
+
+
+PB_BIND(meshtastic_Data, meshtastic_Data, 2)
+
+
+PB_BIND(meshtastic_Waypoint, meshtastic_Waypoint, AUTO)
+
+
+PB_BIND(meshtastic_MqttClientProxyMessage, meshtastic_MqttClientProxyMessage, 2)
+
+
+PB_BIND(meshtastic_MeshPacket, meshtastic_MeshPacket, 2)
+
+
+PB_BIND(meshtastic_NodeInfo, meshtastic_NodeInfo, AUTO)
+
+
+PB_BIND(meshtastic_MyNodeInfo, meshtastic_MyNodeInfo, AUTO)
+
+
+PB_BIND(meshtastic_LogRecord, meshtastic_LogRecord, AUTO)
+
+
+PB_BIND(meshtastic_QueueStatus, meshtastic_QueueStatus, AUTO)
+
+
+PB_BIND(meshtastic_FromRadio, meshtastic_FromRadio, 2)
+
+
+PB_BIND(meshtastic_ToRadio, meshtastic_ToRadio, 2)
+
+
+PB_BIND(meshtastic_Compressed, meshtastic_Compressed, AUTO)
+
+
+PB_BIND(meshtastic_NeighborInfo, meshtastic_NeighborInfo, AUTO)
+
+
+PB_BIND(meshtastic_Neighbor, meshtastic_Neighbor, AUTO)
+
+
+PB_BIND(meshtastic_DeviceMetadata, meshtastic_DeviceMetadata, AUTO)
+
+
+PB_BIND(meshtastic_Heartbeat, meshtastic_Heartbeat, AUTO)
+
+
+PB_BIND(meshtastic_NodeRemoteHardwarePin, meshtastic_NodeRemoteHardwarePin, AUTO)
+
+
+
+
+
+
+
+
+
+
+
+

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

@@ -0,0 +1,62 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#include "meshtastic/module_config.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_ModuleConfig, meshtastic_ModuleConfig, 2)
+
+
+PB_BIND(meshtastic_ModuleConfig_MQTTConfig, meshtastic_ModuleConfig_MQTTConfig, 2)
+
+
+PB_BIND(meshtastic_ModuleConfig_MapReportSettings, meshtastic_ModuleConfig_MapReportSettings, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_RemoteHardwareConfig, meshtastic_ModuleConfig_RemoteHardwareConfig, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_NeighborInfoConfig, meshtastic_ModuleConfig_NeighborInfoConfig, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_DetectionSensorConfig, meshtastic_ModuleConfig_DetectionSensorConfig, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_AudioConfig, meshtastic_ModuleConfig_AudioConfig, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_PaxcounterConfig, meshtastic_ModuleConfig_PaxcounterConfig, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_SerialConfig, meshtastic_ModuleConfig_SerialConfig, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_ExternalNotificationConfig, meshtastic_ModuleConfig_ExternalNotificationConfig, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_StoreForwardConfig, meshtastic_ModuleConfig_StoreForwardConfig, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_RangeTestConfig, meshtastic_ModuleConfig_RangeTestConfig, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_TelemetryConfig, meshtastic_ModuleConfig_TelemetryConfig, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_CannedMessageConfig, meshtastic_ModuleConfig_CannedMessageConfig, AUTO)
+
+
+PB_BIND(meshtastic_ModuleConfig_AmbientLightingConfig, meshtastic_ModuleConfig_AmbientLightingConfig, AUTO)
+
+
+PB_BIND(meshtastic_RemoteHardwarePin, meshtastic_RemoteHardwarePin, AUTO)
+
+
+
+
+
+
+
+

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

@@ -0,0 +1,852 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_MODULE_CONFIG_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_MODULE_CONFIG_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _meshtastic_RemoteHardwarePinType {
+    /* Unset/unused */
+    meshtastic_RemoteHardwarePinType_UNKNOWN = 0,
+    /* GPIO pin can be read (if it is high / low) */
+    meshtastic_RemoteHardwarePinType_DIGITAL_READ = 1,
+    /* GPIO pin can be written to (high / low) */
+    meshtastic_RemoteHardwarePinType_DIGITAL_WRITE = 2
+} meshtastic_RemoteHardwarePinType;
+
+/* Baudrate for codec2 voice */
+typedef enum _meshtastic_ModuleConfig_AudioConfig_Audio_Baud {
+    meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_DEFAULT = 0,
+    meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_3200 = 1,
+    meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_2400 = 2,
+    meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_1600 = 3,
+    meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_1400 = 4,
+    meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_1300 = 5,
+    meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_1200 = 6,
+    meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_700 = 7,
+    meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_700B = 8
+} meshtastic_ModuleConfig_AudioConfig_Audio_Baud;
+
+/* TODO: REPLACE */
+typedef enum _meshtastic_ModuleConfig_SerialConfig_Serial_Baud {
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_DEFAULT = 0,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_110 = 1,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_300 = 2,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_600 = 3,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_1200 = 4,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_2400 = 5,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_4800 = 6,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_9600 = 7,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_19200 = 8,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_38400 = 9,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_57600 = 10,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_115200 = 11,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_230400 = 12,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_460800 = 13,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_576000 = 14,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_921600 = 15
+} meshtastic_ModuleConfig_SerialConfig_Serial_Baud;
+
+/* TODO: REPLACE */
+typedef enum _meshtastic_ModuleConfig_SerialConfig_Serial_Mode {
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_DEFAULT = 0,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_SIMPLE = 1,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_PROTO = 2,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_TEXTMSG = 3,
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_NMEA = 4,
+    /* NMEA messages specifically tailored for CalTopo */
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO = 5
+} meshtastic_ModuleConfig_SerialConfig_Serial_Mode;
+
+/* TODO: REPLACE */
+typedef enum _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar {
+    /* TODO: REPLACE */
+    meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE = 0,
+    /* TODO: REPLACE */
+    meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_UP = 17,
+    /* TODO: REPLACE */
+    meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_DOWN = 18,
+    /* TODO: REPLACE */
+    meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT = 19,
+    /* TODO: REPLACE */
+    meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT = 20,
+    /* '\n' */
+    meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_SELECT = 10,
+    /* TODO: REPLACE */
+    meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_BACK = 27,
+    /* TODO: REPLACE */
+    meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_CANCEL = 24
+} meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar;
+
+/* Struct definitions */
+/* Settings for reporting unencrypted information about our node to a map via MQTT */
+typedef struct _meshtastic_ModuleConfig_MapReportSettings {
+    /* How often we should report our info to the map (in seconds) */
+    uint32_t publish_interval_secs;
+    /* Bits of precision for the location sent (default of 32 is full precision). */
+    uint32_t position_precision;
+} meshtastic_ModuleConfig_MapReportSettings;
+
+/* MQTT Client Config */
+typedef struct _meshtastic_ModuleConfig_MQTTConfig {
+    /* If a meshtastic node is able to reach the internet it will normally attempt to gateway any channels that are marked as
+ is_uplink_enabled or is_downlink_enabled. */
+    bool enabled;
+    /* The server to use for our MQTT global message gateway feature.
+ If not set, the default server will be used */
+    char address[64];
+    /* MQTT username to use (most useful for a custom MQTT server).
+ If using a custom server, this will be honoured even if empty.
+ If using the default server, this will only be honoured if set, otherwise the device will use the default username */
+    char username[64];
+    /* MQTT password to use (most useful for a custom MQTT server).
+ If using a custom server, this will be honoured even if empty.
+ If using the default server, this will only be honoured if set, otherwise the device will use the default password */
+    char password[64];
+    /* Whether to send encrypted or decrypted packets to MQTT.
+ This parameter is only honoured if you also set server
+ (the default official mqtt.meshtastic.org server can handle encrypted packets)
+ Decrypted packets may be useful for external systems that want to consume meshtastic packets */
+    bool encryption_enabled;
+    /* Whether to send / consume json packets on MQTT */
+    bool json_enabled;
+    /* If true, we attempt to establish a secure connection using TLS */
+    bool tls_enabled;
+    /* The root topic to use for MQTT messages. Default is "msh".
+ This is useful if you want to use a single MQTT server for multiple meshtastic networks and separate them via ACLs */
+    char root[32];
+    /* If true, we can use the connected phone / client to proxy messages to MQTT instead of a direct connection */
+    bool proxy_to_client_enabled;
+    /* If true, we will periodically report unencrypted information about our node to a map via MQTT */
+    bool map_reporting_enabled;
+    /* Settings for reporting information about our node to a map via MQTT */
+    bool has_map_report_settings;
+    meshtastic_ModuleConfig_MapReportSettings map_report_settings;
+} meshtastic_ModuleConfig_MQTTConfig;
+
+/* NeighborInfoModule Config */
+typedef struct _meshtastic_ModuleConfig_NeighborInfoConfig {
+    /* Whether the Module is enabled */
+    bool enabled;
+    /* Interval in seconds of how often we should try to send our
+ Neighbor Info to the mesh */
+    uint32_t update_interval;
+} meshtastic_ModuleConfig_NeighborInfoConfig;
+
+/* Detection Sensor Module Config */
+typedef struct _meshtastic_ModuleConfig_DetectionSensorConfig {
+    /* Whether the Module is enabled */
+    bool enabled;
+    /* Interval in seconds of how often we can send a message to the mesh when a state change is detected */
+    uint32_t minimum_broadcast_secs;
+    /* Interval in seconds of how often we should send a message to the mesh with the current state regardless of changes
+ When set to 0, only state changes will be broadcasted
+ Works as a sort of status heartbeat for peace of mind */
+    uint32_t state_broadcast_secs;
+    /* Send ASCII bell with alert message
+ Useful for triggering ext. notification on bell */
+    bool send_bell;
+    /* Friendly name used to format message sent to mesh
+ Example: A name "Motion" would result in a message "Motion detected"
+ Maximum length of 20 characters */
+    char name[20];
+    /* GPIO pin to monitor for state changes */
+    uint8_t monitor_pin;
+    /* Whether or not the GPIO pin state detection is triggered on HIGH (1)
+ Otherwise LOW (0) */
+    bool detection_triggered_high;
+    /* Whether or not use INPUT_PULLUP mode for GPIO pin
+ Only applicable if the board uses pull-up resistors on the pin */
+    bool use_pullup;
+} meshtastic_ModuleConfig_DetectionSensorConfig;
+
+/* Audio Config for codec2 voice */
+typedef struct _meshtastic_ModuleConfig_AudioConfig {
+    /* Whether Audio is enabled */
+    bool codec2_enabled;
+    /* PTT Pin */
+    uint8_t ptt_pin;
+    /* The audio sample rate to use for codec2 */
+    meshtastic_ModuleConfig_AudioConfig_Audio_Baud bitrate;
+    /* I2S Word Select */
+    uint8_t i2s_ws;
+    /* I2S Data IN */
+    uint8_t i2s_sd;
+    /* I2S Data OUT */
+    uint8_t i2s_din;
+    /* I2S Clock */
+    uint8_t i2s_sck;
+} meshtastic_ModuleConfig_AudioConfig;
+
+/* Config for the Paxcounter Module */
+typedef struct _meshtastic_ModuleConfig_PaxcounterConfig {
+    /* Enable the Paxcounter Module */
+    bool enabled;
+    uint32_t paxcounter_update_interval;
+} meshtastic_ModuleConfig_PaxcounterConfig;
+
+/* Serial Config */
+typedef struct _meshtastic_ModuleConfig_SerialConfig {
+    /* Preferences for the SerialModule */
+    bool enabled;
+    /* TODO: REPLACE */
+    bool echo;
+    /* RX pin (should match Arduino gpio pin number) */
+    uint32_t rxd;
+    /* TX pin (should match Arduino gpio pin number) */
+    uint32_t txd;
+    /* Serial baud rate */
+    meshtastic_ModuleConfig_SerialConfig_Serial_Baud baud;
+    /* TODO: REPLACE */
+    uint32_t timeout;
+    /* Mode for serial module operation */
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode mode;
+    /* Overrides the platform's defacto Serial port instance to use with Serial module config settings
+ This is currently only usable in output modes like NMEA / CalTopo and may behave strangely or not work at all in other modes
+ Existing logging over the Serial Console will still be present */
+    bool override_console_serial_port;
+} meshtastic_ModuleConfig_SerialConfig;
+
+/* External Notifications Config */
+typedef struct _meshtastic_ModuleConfig_ExternalNotificationConfig {
+    /* Enable the ExternalNotificationModule */
+    bool enabled;
+    /* When using in On/Off mode, keep the output on for this many
+ milliseconds. Default 1000ms (1 second). */
+    uint32_t output_ms;
+    /* Define the output pin GPIO setting Defaults to
+ EXT_NOTIFY_OUT if set for the board.
+ In standalone devices this pin should drive the LED to match the UI. */
+    uint32_t output;
+    /* IF this is true, the 'output' Pin will be pulled active high, false
+ means active low. */
+    bool active;
+    /* True: Alert when a text message arrives (output) */
+    bool alert_message;
+    /* True: Alert when the bell character is received (output) */
+    bool alert_bell;
+    /* use a PWM output instead of a simple on/off output. This will ignore
+ the 'output', 'output_ms' and 'active' settings and use the
+ device.buzzer_gpio instead. */
+    bool use_pwm;
+    /* Optional: Define a secondary output pin for a vibra motor
+ This is used in standalone devices to match the UI. */
+    uint8_t output_vibra;
+    /* Optional: Define a tertiary output pin for an active buzzer
+ This is used in standalone devices to to match the UI. */
+    uint8_t output_buzzer;
+    /* True: Alert when a text message arrives (output_vibra) */
+    bool alert_message_vibra;
+    /* True: Alert when a text message arrives (output_buzzer) */
+    bool alert_message_buzzer;
+    /* True: Alert when the bell character is received (output_vibra) */
+    bool alert_bell_vibra;
+    /* True: Alert when the bell character is received (output_buzzer) */
+    bool alert_bell_buzzer;
+    /* The notification will toggle with 'output_ms' for this time of seconds.
+ Default is 0 which means don't repeat at all. 60 would mean blink
+ and/or beep for 60 seconds */
+    uint16_t nag_timeout;
+    /* When true, enables devices with native I2S audio output to use the RTTTL over speaker like a buzzer
+ T-Watch S3 and T-Deck for example have this capability */
+    bool use_i2s_as_buzzer;
+} meshtastic_ModuleConfig_ExternalNotificationConfig;
+
+/* Store and Forward Module Config */
+typedef struct _meshtastic_ModuleConfig_StoreForwardConfig {
+    /* Enable the Store and Forward Module */
+    bool enabled;
+    /* TODO: REPLACE */
+    bool heartbeat;
+    /* TODO: REPLACE */
+    uint32_t records;
+    /* TODO: REPLACE */
+    uint32_t history_return_max;
+    /* TODO: REPLACE */
+    uint32_t history_return_window;
+} meshtastic_ModuleConfig_StoreForwardConfig;
+
+/* Preferences for the RangeTestModule */
+typedef struct _meshtastic_ModuleConfig_RangeTestConfig {
+    /* Enable the Range Test Module */
+    bool enabled;
+    /* Send out range test messages from this node */
+    uint32_t sender;
+    /* Bool value indicating that this node should save a RangeTest.csv file.
+ ESP32 Only */
+    bool save;
+} meshtastic_ModuleConfig_RangeTestConfig;
+
+/* Configuration for both device and environment metrics */
+typedef struct _meshtastic_ModuleConfig_TelemetryConfig {
+    /* Interval in seconds of how often we should try to send our
+ device metrics to the mesh */
+    uint32_t device_update_interval;
+    uint32_t environment_update_interval;
+    /* Preferences for the Telemetry Module (Environment)
+ Enable/Disable the telemetry measurement module measurement collection */
+    bool environment_measurement_enabled;
+    /* Enable/Disable the telemetry measurement module on-device display */
+    bool environment_screen_enabled;
+    /* 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;
+    /* Interval in seconds of how often we should try to send our
+ air quality metrics to the mesh */
+    bool power_measurement_enabled;
+    /* Interval in seconds of how often we should try to send our
+ air quality metrics to the mesh */
+    uint32_t power_update_interval;
+    /* Interval in seconds of how often we should try to send our
+ air quality metrics to the mesh */
+    bool power_screen_enabled;
+} meshtastic_ModuleConfig_TelemetryConfig;
+
+/* TODO: REPLACE */
+typedef struct _meshtastic_ModuleConfig_CannedMessageConfig {
+    /* Enable the rotary encoder #1. This is a 'dumb' encoder sending pulses on both A and B pins while rotating. */
+    bool rotary1_enabled;
+    /* GPIO pin for rotary encoder A port. */
+    uint32_t inputbroker_pin_a;
+    /* GPIO pin for rotary encoder B port. */
+    uint32_t inputbroker_pin_b;
+    /* GPIO pin for rotary encoder Press port. */
+    uint32_t inputbroker_pin_press;
+    /* Generate input event on CW of this kind. */
+    meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar inputbroker_event_cw;
+    /* Generate input event on CCW of this kind. */
+    meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar inputbroker_event_ccw;
+    /* Generate input event on Press of this kind. */
+    meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar inputbroker_event_press;
+    /* Enable the Up/Down/Select input device. Can be RAK rotary encoder or 3 buttons. Uses the a/b/press definitions from inputbroker. */
+    bool updown1_enabled;
+    /* Enable/disable CannedMessageModule. */
+    bool enabled;
+    /* Input event origin accepted by the canned message module.
+ Can be e.g. "rotEnc1", "upDownEnc1" or keyword "_any" */
+    char allow_input_source[16];
+    /* CannedMessageModule also sends a bell character with the messages.
+ ExternalNotificationModule can benefit from this feature. */
+    bool send_bell;
+} meshtastic_ModuleConfig_CannedMessageConfig;
+
+/* Ambient Lighting Module - Settings for control of onboard LEDs to allow users to adjust the brightness levels and respective color levels.
+Initially created for the RAK14001 RGB LED module. */
+typedef struct _meshtastic_ModuleConfig_AmbientLightingConfig {
+    /* Sets LED to on or off. */
+    bool led_state;
+    /* Sets the current for the LED output. Default is 10. */
+    uint8_t current;
+    /* Sets the red LED level. Values are 0-255. */
+    uint8_t red;
+    /* Sets the green LED level. Values are 0-255. */
+    uint8_t green;
+    /* Sets the blue LED level. Values are 0-255. */
+    uint8_t blue;
+} meshtastic_ModuleConfig_AmbientLightingConfig;
+
+/* A GPIO pin definition for remote hardware module */
+typedef struct _meshtastic_RemoteHardwarePin {
+    /* GPIO Pin number (must match Arduino) */
+    uint8_t gpio_pin;
+    /* Name for the GPIO pin (i.e. Front gate, mailbox, etc) */
+    char name[15];
+    /* Type of GPIO access available to consumers on the mesh */
+    meshtastic_RemoteHardwarePinType type;
+} meshtastic_RemoteHardwarePin;
+
+/* RemoteHardwareModule Config */
+typedef struct _meshtastic_ModuleConfig_RemoteHardwareConfig {
+    /* Whether the Module is enabled */
+    bool enabled;
+    /* Whether the Module allows consumers to read / write to pins not defined in available_pins */
+    bool allow_undefined_pin_access;
+    /* Exposes the available pins to the mesh for reading and writing */
+    pb_size_t available_pins_count;
+    meshtastic_RemoteHardwarePin available_pins[4];
+} meshtastic_ModuleConfig_RemoteHardwareConfig;
+
+/* Module Config */
+typedef struct _meshtastic_ModuleConfig {
+    pb_size_t which_payload_variant;
+    union {
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_MQTTConfig mqtt;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_SerialConfig serial;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_ExternalNotificationConfig external_notification;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_StoreForwardConfig store_forward;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_RangeTestConfig range_test;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_TelemetryConfig telemetry;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_CannedMessageConfig canned_message;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_AudioConfig audio;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_RemoteHardwareConfig remote_hardware;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_NeighborInfoConfig neighbor_info;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_AmbientLightingConfig ambient_lighting;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_DetectionSensorConfig detection_sensor;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_PaxcounterConfig paxcounter;
+    } payload_variant;
+} meshtastic_ModuleConfig;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_RemoteHardwarePinType_MIN meshtastic_RemoteHardwarePinType_UNKNOWN
+#define _meshtastic_RemoteHardwarePinType_MAX meshtastic_RemoteHardwarePinType_DIGITAL_WRITE
+#define _meshtastic_RemoteHardwarePinType_ARRAYSIZE ((meshtastic_RemoteHardwarePinType)(meshtastic_RemoteHardwarePinType_DIGITAL_WRITE+1))
+
+#define _meshtastic_ModuleConfig_AudioConfig_Audio_Baud_MIN meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_DEFAULT
+#define _meshtastic_ModuleConfig_AudioConfig_Audio_Baud_MAX meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_700B
+#define _meshtastic_ModuleConfig_AudioConfig_Audio_Baud_ARRAYSIZE ((meshtastic_ModuleConfig_AudioConfig_Audio_Baud)(meshtastic_ModuleConfig_AudioConfig_Audio_Baud_CODEC2_700B+1))
+
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MIN meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_DEFAULT
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MAX meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_921600
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_ARRAYSIZE ((meshtastic_ModuleConfig_SerialConfig_Serial_Baud)(meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_921600+1))
+
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN meshtastic_ModuleConfig_SerialConfig_Serial_Mode_DEFAULT
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MAX meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_ARRAYSIZE ((meshtastic_ModuleConfig_SerialConfig_Serial_Mode)(meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO+1))
+
+#define _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE
+#define _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MAX meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_BACK
+#define _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_ARRAYSIZE ((meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar)(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_BACK+1))
+
+
+
+
+
+
+
+#define meshtastic_ModuleConfig_AudioConfig_bitrate_ENUMTYPE meshtastic_ModuleConfig_AudioConfig_Audio_Baud
+
+
+#define meshtastic_ModuleConfig_SerialConfig_baud_ENUMTYPE meshtastic_ModuleConfig_SerialConfig_Serial_Baud
+#define meshtastic_ModuleConfig_SerialConfig_mode_ENUMTYPE meshtastic_ModuleConfig_SerialConfig_Serial_Mode
+
+
+
+
+
+#define meshtastic_ModuleConfig_CannedMessageConfig_inputbroker_event_cw_ENUMTYPE meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar
+#define meshtastic_ModuleConfig_CannedMessageConfig_inputbroker_event_ccw_ENUMTYPE meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar
+#define meshtastic_ModuleConfig_CannedMessageConfig_inputbroker_event_press_ENUMTYPE meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar
+
+
+#define meshtastic_RemoteHardwarePin_type_ENUMTYPE meshtastic_RemoteHardwarePinType
+
+
+/* Initializer values for message structs */
+#define meshtastic_ModuleConfig_init_default     {0, {meshtastic_ModuleConfig_MQTTConfig_init_default}}
+#define meshtastic_ModuleConfig_MQTTConfig_init_default {0, "", "", "", 0, 0, 0, "", 0, 0, false, meshtastic_ModuleConfig_MapReportSettings_init_default}
+#define meshtastic_ModuleConfig_MapReportSettings_init_default {0, 0}
+#define meshtastic_ModuleConfig_RemoteHardwareConfig_init_default {0, 0, 0, {meshtastic_RemoteHardwarePin_init_default, meshtastic_RemoteHardwarePin_init_default, meshtastic_RemoteHardwarePin_init_default, meshtastic_RemoteHardwarePin_init_default}}
+#define meshtastic_ModuleConfig_NeighborInfoConfig_init_default {0, 0}
+#define meshtastic_ModuleConfig_DetectionSensorConfig_init_default {0, 0, 0, 0, "", 0, 0, 0}
+#define meshtastic_ModuleConfig_AudioConfig_init_default {0, 0, _meshtastic_ModuleConfig_AudioConfig_Audio_Baud_MIN, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_PaxcounterConfig_init_default {0, 0}
+#define meshtastic_ModuleConfig_SerialConfig_init_default {0, 0, 0, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MIN, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN, 0}
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_init_default {0, 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, 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_AmbientLightingConfig_init_default {0, 0, 0, 0, 0}
+#define meshtastic_RemoteHardwarePin_init_default {0, "", _meshtastic_RemoteHardwarePinType_MIN}
+#define meshtastic_ModuleConfig_init_zero        {0, {meshtastic_ModuleConfig_MQTTConfig_init_zero}}
+#define meshtastic_ModuleConfig_MQTTConfig_init_zero {0, "", "", "", 0, 0, 0, "", 0, 0, false, meshtastic_ModuleConfig_MapReportSettings_init_zero}
+#define meshtastic_ModuleConfig_MapReportSettings_init_zero {0, 0}
+#define meshtastic_ModuleConfig_RemoteHardwareConfig_init_zero {0, 0, 0, {meshtastic_RemoteHardwarePin_init_zero, meshtastic_RemoteHardwarePin_init_zero, meshtastic_RemoteHardwarePin_init_zero, meshtastic_RemoteHardwarePin_init_zero}}
+#define meshtastic_ModuleConfig_NeighborInfoConfig_init_zero {0, 0}
+#define meshtastic_ModuleConfig_DetectionSensorConfig_init_zero {0, 0, 0, 0, "", 0, 0, 0}
+#define meshtastic_ModuleConfig_AudioConfig_init_zero {0, 0, _meshtastic_ModuleConfig_AudioConfig_Audio_Baud_MIN, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_PaxcounterConfig_init_zero {0, 0}
+#define meshtastic_ModuleConfig_SerialConfig_init_zero {0, 0, 0, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MIN, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN, 0}
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_init_zero {0, 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, 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}
+#define meshtastic_ModuleConfig_AmbientLightingConfig_init_zero {0, 0, 0, 0, 0}
+#define meshtastic_RemoteHardwarePin_init_zero   {0, "", _meshtastic_RemoteHardwarePinType_MIN}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_ModuleConfig_MapReportSettings_publish_interval_secs_tag 1
+#define meshtastic_ModuleConfig_MapReportSettings_position_precision_tag 2
+#define meshtastic_ModuleConfig_MQTTConfig_enabled_tag 1
+#define meshtastic_ModuleConfig_MQTTConfig_address_tag 2
+#define meshtastic_ModuleConfig_MQTTConfig_username_tag 3
+#define meshtastic_ModuleConfig_MQTTConfig_password_tag 4
+#define meshtastic_ModuleConfig_MQTTConfig_encryption_enabled_tag 5
+#define meshtastic_ModuleConfig_MQTTConfig_json_enabled_tag 6
+#define meshtastic_ModuleConfig_MQTTConfig_tls_enabled_tag 7
+#define meshtastic_ModuleConfig_MQTTConfig_root_tag 8
+#define meshtastic_ModuleConfig_MQTTConfig_proxy_to_client_enabled_tag 9
+#define meshtastic_ModuleConfig_MQTTConfig_map_reporting_enabled_tag 10
+#define meshtastic_ModuleConfig_MQTTConfig_map_report_settings_tag 11
+#define meshtastic_ModuleConfig_NeighborInfoConfig_enabled_tag 1
+#define meshtastic_ModuleConfig_NeighborInfoConfig_update_interval_tag 2
+#define meshtastic_ModuleConfig_DetectionSensorConfig_enabled_tag 1
+#define meshtastic_ModuleConfig_DetectionSensorConfig_minimum_broadcast_secs_tag 2
+#define meshtastic_ModuleConfig_DetectionSensorConfig_state_broadcast_secs_tag 3
+#define meshtastic_ModuleConfig_DetectionSensorConfig_send_bell_tag 4
+#define meshtastic_ModuleConfig_DetectionSensorConfig_name_tag 5
+#define meshtastic_ModuleConfig_DetectionSensorConfig_monitor_pin_tag 6
+#define meshtastic_ModuleConfig_DetectionSensorConfig_detection_triggered_high_tag 7
+#define meshtastic_ModuleConfig_DetectionSensorConfig_use_pullup_tag 8
+#define meshtastic_ModuleConfig_AudioConfig_codec2_enabled_tag 1
+#define meshtastic_ModuleConfig_AudioConfig_ptt_pin_tag 2
+#define meshtastic_ModuleConfig_AudioConfig_bitrate_tag 3
+#define meshtastic_ModuleConfig_AudioConfig_i2s_ws_tag 4
+#define meshtastic_ModuleConfig_AudioConfig_i2s_sd_tag 5
+#define meshtastic_ModuleConfig_AudioConfig_i2s_din_tag 6
+#define meshtastic_ModuleConfig_AudioConfig_i2s_sck_tag 7
+#define meshtastic_ModuleConfig_PaxcounterConfig_enabled_tag 1
+#define meshtastic_ModuleConfig_PaxcounterConfig_paxcounter_update_interval_tag 2
+#define meshtastic_ModuleConfig_SerialConfig_enabled_tag 1
+#define meshtastic_ModuleConfig_SerialConfig_echo_tag 2
+#define meshtastic_ModuleConfig_SerialConfig_rxd_tag 3
+#define meshtastic_ModuleConfig_SerialConfig_txd_tag 4
+#define meshtastic_ModuleConfig_SerialConfig_baud_tag 5
+#define meshtastic_ModuleConfig_SerialConfig_timeout_tag 6
+#define meshtastic_ModuleConfig_SerialConfig_mode_tag 7
+#define meshtastic_ModuleConfig_SerialConfig_override_console_serial_port_tag 8
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_enabled_tag 1
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_output_ms_tag 2
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_output_tag 3
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_active_tag 4
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_alert_message_tag 5
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_alert_bell_tag 6
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_use_pwm_tag 7
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_output_vibra_tag 8
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_output_buzzer_tag 9
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_alert_message_vibra_tag 10
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_alert_message_buzzer_tag 11
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_alert_bell_vibra_tag 12
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_alert_bell_buzzer_tag 13
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_nag_timeout_tag 14
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_use_i2s_as_buzzer_tag 15
+#define meshtastic_ModuleConfig_StoreForwardConfig_enabled_tag 1
+#define meshtastic_ModuleConfig_StoreForwardConfig_heartbeat_tag 2
+#define meshtastic_ModuleConfig_StoreForwardConfig_records_tag 3
+#define meshtastic_ModuleConfig_StoreForwardConfig_history_return_max_tag 4
+#define meshtastic_ModuleConfig_StoreForwardConfig_history_return_window_tag 5
+#define meshtastic_ModuleConfig_RangeTestConfig_enabled_tag 1
+#define meshtastic_ModuleConfig_RangeTestConfig_sender_tag 2
+#define meshtastic_ModuleConfig_RangeTestConfig_save_tag 3
+#define meshtastic_ModuleConfig_TelemetryConfig_device_update_interval_tag 1
+#define meshtastic_ModuleConfig_TelemetryConfig_environment_update_interval_tag 2
+#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_TelemetryConfig_power_measurement_enabled_tag 8
+#define meshtastic_ModuleConfig_TelemetryConfig_power_update_interval_tag 9
+#define meshtastic_ModuleConfig_TelemetryConfig_power_screen_enabled_tag 10
+#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
+#define meshtastic_ModuleConfig_CannedMessageConfig_inputbroker_pin_press_tag 4
+#define meshtastic_ModuleConfig_CannedMessageConfig_inputbroker_event_cw_tag 5
+#define meshtastic_ModuleConfig_CannedMessageConfig_inputbroker_event_ccw_tag 6
+#define meshtastic_ModuleConfig_CannedMessageConfig_inputbroker_event_press_tag 7
+#define meshtastic_ModuleConfig_CannedMessageConfig_updown1_enabled_tag 8
+#define meshtastic_ModuleConfig_CannedMessageConfig_enabled_tag 9
+#define meshtastic_ModuleConfig_CannedMessageConfig_allow_input_source_tag 10
+#define meshtastic_ModuleConfig_CannedMessageConfig_send_bell_tag 11
+#define meshtastic_ModuleConfig_AmbientLightingConfig_led_state_tag 1
+#define meshtastic_ModuleConfig_AmbientLightingConfig_current_tag 2
+#define meshtastic_ModuleConfig_AmbientLightingConfig_red_tag 3
+#define meshtastic_ModuleConfig_AmbientLightingConfig_green_tag 4
+#define meshtastic_ModuleConfig_AmbientLightingConfig_blue_tag 5
+#define meshtastic_RemoteHardwarePin_gpio_pin_tag 1
+#define meshtastic_RemoteHardwarePin_name_tag    2
+#define meshtastic_RemoteHardwarePin_type_tag    3
+#define meshtastic_ModuleConfig_RemoteHardwareConfig_enabled_tag 1
+#define meshtastic_ModuleConfig_RemoteHardwareConfig_allow_undefined_pin_access_tag 2
+#define meshtastic_ModuleConfig_RemoteHardwareConfig_available_pins_tag 3
+#define meshtastic_ModuleConfig_mqtt_tag         1
+#define meshtastic_ModuleConfig_serial_tag       2
+#define meshtastic_ModuleConfig_external_notification_tag 3
+#define meshtastic_ModuleConfig_store_forward_tag 4
+#define meshtastic_ModuleConfig_range_test_tag   5
+#define meshtastic_ModuleConfig_telemetry_tag    6
+#define meshtastic_ModuleConfig_canned_message_tag 7
+#define meshtastic_ModuleConfig_audio_tag        8
+#define meshtastic_ModuleConfig_remote_hardware_tag 9
+#define meshtastic_ModuleConfig_neighbor_info_tag 10
+#define meshtastic_ModuleConfig_ambient_lighting_tag 11
+#define meshtastic_ModuleConfig_detection_sensor_tag 12
+#define meshtastic_ModuleConfig_paxcounter_tag   13
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_ModuleConfig_FIELDLIST(X, a) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,mqtt,payload_variant.mqtt),   1) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,serial,payload_variant.serial),   2) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,external_notification,payload_variant.external_notification),   3) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,store_forward,payload_variant.store_forward),   4) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,range_test,payload_variant.range_test),   5) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,telemetry,payload_variant.telemetry),   6) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,canned_message,payload_variant.canned_message),   7) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,audio,payload_variant.audio),   8) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,remote_hardware,payload_variant.remote_hardware),   9) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,neighbor_info,payload_variant.neighbor_info),  10) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,ambient_lighting,payload_variant.ambient_lighting),  11) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,detection_sensor,payload_variant.detection_sensor),  12) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,paxcounter,payload_variant.paxcounter),  13)
+#define meshtastic_ModuleConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_DEFAULT NULL
+#define meshtastic_ModuleConfig_payload_variant_mqtt_MSGTYPE meshtastic_ModuleConfig_MQTTConfig
+#define meshtastic_ModuleConfig_payload_variant_serial_MSGTYPE meshtastic_ModuleConfig_SerialConfig
+#define meshtastic_ModuleConfig_payload_variant_external_notification_MSGTYPE meshtastic_ModuleConfig_ExternalNotificationConfig
+#define meshtastic_ModuleConfig_payload_variant_store_forward_MSGTYPE meshtastic_ModuleConfig_StoreForwardConfig
+#define meshtastic_ModuleConfig_payload_variant_range_test_MSGTYPE meshtastic_ModuleConfig_RangeTestConfig
+#define meshtastic_ModuleConfig_payload_variant_telemetry_MSGTYPE meshtastic_ModuleConfig_TelemetryConfig
+#define meshtastic_ModuleConfig_payload_variant_canned_message_MSGTYPE meshtastic_ModuleConfig_CannedMessageConfig
+#define meshtastic_ModuleConfig_payload_variant_audio_MSGTYPE meshtastic_ModuleConfig_AudioConfig
+#define meshtastic_ModuleConfig_payload_variant_remote_hardware_MSGTYPE meshtastic_ModuleConfig_RemoteHardwareConfig
+#define meshtastic_ModuleConfig_payload_variant_neighbor_info_MSGTYPE meshtastic_ModuleConfig_NeighborInfoConfig
+#define meshtastic_ModuleConfig_payload_variant_ambient_lighting_MSGTYPE meshtastic_ModuleConfig_AmbientLightingConfig
+#define meshtastic_ModuleConfig_payload_variant_detection_sensor_MSGTYPE meshtastic_ModuleConfig_DetectionSensorConfig
+#define meshtastic_ModuleConfig_payload_variant_paxcounter_MSGTYPE meshtastic_ModuleConfig_PaxcounterConfig
+
+#define meshtastic_ModuleConfig_MQTTConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
+X(a, STATIC,   SINGULAR, STRING,   address,           2) \
+X(a, STATIC,   SINGULAR, STRING,   username,          3) \
+X(a, STATIC,   SINGULAR, STRING,   password,          4) \
+X(a, STATIC,   SINGULAR, BOOL,     encryption_enabled,   5) \
+X(a, STATIC,   SINGULAR, BOOL,     json_enabled,      6) \
+X(a, STATIC,   SINGULAR, BOOL,     tls_enabled,       7) \
+X(a, STATIC,   SINGULAR, STRING,   root,              8) \
+X(a, STATIC,   SINGULAR, BOOL,     proxy_to_client_enabled,   9) \
+X(a, STATIC,   SINGULAR, BOOL,     map_reporting_enabled,  10) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  map_report_settings,  11)
+#define meshtastic_ModuleConfig_MQTTConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_MQTTConfig_DEFAULT NULL
+#define meshtastic_ModuleConfig_MQTTConfig_map_report_settings_MSGTYPE meshtastic_ModuleConfig_MapReportSettings
+
+#define meshtastic_ModuleConfig_MapReportSettings_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   publish_interval_secs,   1) \
+X(a, STATIC,   SINGULAR, UINT32,   position_precision,   2)
+#define meshtastic_ModuleConfig_MapReportSettings_CALLBACK NULL
+#define meshtastic_ModuleConfig_MapReportSettings_DEFAULT NULL
+
+#define meshtastic_ModuleConfig_RemoteHardwareConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
+X(a, STATIC,   SINGULAR, BOOL,     allow_undefined_pin_access,   2) \
+X(a, STATIC,   REPEATED, MESSAGE,  available_pins,    3)
+#define meshtastic_ModuleConfig_RemoteHardwareConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_RemoteHardwareConfig_DEFAULT NULL
+#define meshtastic_ModuleConfig_RemoteHardwareConfig_available_pins_MSGTYPE meshtastic_RemoteHardwarePin
+
+#define meshtastic_ModuleConfig_NeighborInfoConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
+X(a, STATIC,   SINGULAR, UINT32,   update_interval,   2)
+#define meshtastic_ModuleConfig_NeighborInfoConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_NeighborInfoConfig_DEFAULT NULL
+
+#define meshtastic_ModuleConfig_DetectionSensorConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
+X(a, STATIC,   SINGULAR, UINT32,   minimum_broadcast_secs,   2) \
+X(a, STATIC,   SINGULAR, UINT32,   state_broadcast_secs,   3) \
+X(a, STATIC,   SINGULAR, BOOL,     send_bell,         4) \
+X(a, STATIC,   SINGULAR, STRING,   name,              5) \
+X(a, STATIC,   SINGULAR, UINT32,   monitor_pin,       6) \
+X(a, STATIC,   SINGULAR, BOOL,     detection_triggered_high,   7) \
+X(a, STATIC,   SINGULAR, BOOL,     use_pullup,        8)
+#define meshtastic_ModuleConfig_DetectionSensorConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_DetectionSensorConfig_DEFAULT NULL
+
+#define meshtastic_ModuleConfig_AudioConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     codec2_enabled,    1) \
+X(a, STATIC,   SINGULAR, UINT32,   ptt_pin,           2) \
+X(a, STATIC,   SINGULAR, UENUM,    bitrate,           3) \
+X(a, STATIC,   SINGULAR, UINT32,   i2s_ws,            4) \
+X(a, STATIC,   SINGULAR, UINT32,   i2s_sd,            5) \
+X(a, STATIC,   SINGULAR, UINT32,   i2s_din,           6) \
+X(a, STATIC,   SINGULAR, UINT32,   i2s_sck,           7)
+#define meshtastic_ModuleConfig_AudioConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_AudioConfig_DEFAULT NULL
+
+#define meshtastic_ModuleConfig_PaxcounterConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
+X(a, STATIC,   SINGULAR, UINT32,   paxcounter_update_interval,   2)
+#define meshtastic_ModuleConfig_PaxcounterConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_PaxcounterConfig_DEFAULT NULL
+
+#define meshtastic_ModuleConfig_SerialConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
+X(a, STATIC,   SINGULAR, BOOL,     echo,              2) \
+X(a, STATIC,   SINGULAR, UINT32,   rxd,               3) \
+X(a, STATIC,   SINGULAR, UINT32,   txd,               4) \
+X(a, STATIC,   SINGULAR, UENUM,    baud,              5) \
+X(a, STATIC,   SINGULAR, UINT32,   timeout,           6) \
+X(a, STATIC,   SINGULAR, UENUM,    mode,              7) \
+X(a, STATIC,   SINGULAR, BOOL,     override_console_serial_port,   8)
+#define meshtastic_ModuleConfig_SerialConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_SerialConfig_DEFAULT NULL
+
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
+X(a, STATIC,   SINGULAR, UINT32,   output_ms,         2) \
+X(a, STATIC,   SINGULAR, UINT32,   output,            3) \
+X(a, STATIC,   SINGULAR, BOOL,     active,            4) \
+X(a, STATIC,   SINGULAR, BOOL,     alert_message,     5) \
+X(a, STATIC,   SINGULAR, BOOL,     alert_bell,        6) \
+X(a, STATIC,   SINGULAR, BOOL,     use_pwm,           7) \
+X(a, STATIC,   SINGULAR, UINT32,   output_vibra,      8) \
+X(a, STATIC,   SINGULAR, UINT32,   output_buzzer,     9) \
+X(a, STATIC,   SINGULAR, BOOL,     alert_message_vibra,  10) \
+X(a, STATIC,   SINGULAR, BOOL,     alert_message_buzzer,  11) \
+X(a, STATIC,   SINGULAR, BOOL,     alert_bell_vibra,  12) \
+X(a, STATIC,   SINGULAR, BOOL,     alert_bell_buzzer,  13) \
+X(a, STATIC,   SINGULAR, UINT32,   nag_timeout,      14) \
+X(a, STATIC,   SINGULAR, BOOL,     use_i2s_as_buzzer,  15)
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_DEFAULT NULL
+
+#define meshtastic_ModuleConfig_StoreForwardConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
+X(a, STATIC,   SINGULAR, BOOL,     heartbeat,         2) \
+X(a, STATIC,   SINGULAR, UINT32,   records,           3) \
+X(a, STATIC,   SINGULAR, UINT32,   history_return_max,   4) \
+X(a, STATIC,   SINGULAR, UINT32,   history_return_window,   5)
+#define meshtastic_ModuleConfig_StoreForwardConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_StoreForwardConfig_DEFAULT NULL
+
+#define meshtastic_ModuleConfig_RangeTestConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
+X(a, STATIC,   SINGULAR, UINT32,   sender,            2) \
+X(a, STATIC,   SINGULAR, BOOL,     save,              3)
+#define meshtastic_ModuleConfig_RangeTestConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_RangeTestConfig_DEFAULT NULL
+
+#define meshtastic_ModuleConfig_TelemetryConfig_FIELDLIST(X, a) \
+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,     air_quality_enabled,   6) \
+X(a, STATIC,   SINGULAR, UINT32,   air_quality_interval,   7) \
+X(a, STATIC,   SINGULAR, BOOL,     power_measurement_enabled,   8) \
+X(a, STATIC,   SINGULAR, UINT32,   power_update_interval,   9) \
+X(a, STATIC,   SINGULAR, BOOL,     power_screen_enabled,  10)
+#define meshtastic_ModuleConfig_TelemetryConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_TelemetryConfig_DEFAULT NULL
+
+#define meshtastic_ModuleConfig_CannedMessageConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     rotary1_enabled,   1) \
+X(a, STATIC,   SINGULAR, UINT32,   inputbroker_pin_a,   2) \
+X(a, STATIC,   SINGULAR, UINT32,   inputbroker_pin_b,   3) \
+X(a, STATIC,   SINGULAR, UINT32,   inputbroker_pin_press,   4) \
+X(a, STATIC,   SINGULAR, UENUM,    inputbroker_event_cw,   5) \
+X(a, STATIC,   SINGULAR, UENUM,    inputbroker_event_ccw,   6) \
+X(a, STATIC,   SINGULAR, UENUM,    inputbroker_event_press,   7) \
+X(a, STATIC,   SINGULAR, BOOL,     updown1_enabled,   8) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           9) \
+X(a, STATIC,   SINGULAR, STRING,   allow_input_source,  10) \
+X(a, STATIC,   SINGULAR, BOOL,     send_bell,        11)
+#define meshtastic_ModuleConfig_CannedMessageConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_CannedMessageConfig_DEFAULT NULL
+
+#define meshtastic_ModuleConfig_AmbientLightingConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     led_state,         1) \
+X(a, STATIC,   SINGULAR, UINT32,   current,           2) \
+X(a, STATIC,   SINGULAR, UINT32,   red,               3) \
+X(a, STATIC,   SINGULAR, UINT32,   green,             4) \
+X(a, STATIC,   SINGULAR, UINT32,   blue,              5)
+#define meshtastic_ModuleConfig_AmbientLightingConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_AmbientLightingConfig_DEFAULT NULL
+
+#define meshtastic_RemoteHardwarePin_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   gpio_pin,          1) \
+X(a, STATIC,   SINGULAR, STRING,   name,              2) \
+X(a, STATIC,   SINGULAR, UENUM,    type,              3)
+#define meshtastic_RemoteHardwarePin_CALLBACK NULL
+#define meshtastic_RemoteHardwarePin_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_ModuleConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_MQTTConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_MapReportSettings_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_RemoteHardwareConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_NeighborInfoConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_DetectionSensorConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_AudioConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_PaxcounterConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_SerialConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_ExternalNotificationConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_StoreForwardConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_RangeTestConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_TelemetryConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_CannedMessageConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_AmbientLightingConfig_msg;
+extern const pb_msgdesc_t meshtastic_RemoteHardwarePin_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_ModuleConfig_fields &meshtastic_ModuleConfig_msg
+#define meshtastic_ModuleConfig_MQTTConfig_fields &meshtastic_ModuleConfig_MQTTConfig_msg
+#define meshtastic_ModuleConfig_MapReportSettings_fields &meshtastic_ModuleConfig_MapReportSettings_msg
+#define meshtastic_ModuleConfig_RemoteHardwareConfig_fields &meshtastic_ModuleConfig_RemoteHardwareConfig_msg
+#define meshtastic_ModuleConfig_NeighborInfoConfig_fields &meshtastic_ModuleConfig_NeighborInfoConfig_msg
+#define meshtastic_ModuleConfig_DetectionSensorConfig_fields &meshtastic_ModuleConfig_DetectionSensorConfig_msg
+#define meshtastic_ModuleConfig_AudioConfig_fields &meshtastic_ModuleConfig_AudioConfig_msg
+#define meshtastic_ModuleConfig_PaxcounterConfig_fields &meshtastic_ModuleConfig_PaxcounterConfig_msg
+#define meshtastic_ModuleConfig_SerialConfig_fields &meshtastic_ModuleConfig_SerialConfig_msg
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_fields &meshtastic_ModuleConfig_ExternalNotificationConfig_msg
+#define meshtastic_ModuleConfig_StoreForwardConfig_fields &meshtastic_ModuleConfig_StoreForwardConfig_msg
+#define meshtastic_ModuleConfig_RangeTestConfig_fields &meshtastic_ModuleConfig_RangeTestConfig_msg
+#define meshtastic_ModuleConfig_TelemetryConfig_fields &meshtastic_ModuleConfig_TelemetryConfig_msg
+#define meshtastic_ModuleConfig_CannedMessageConfig_fields &meshtastic_ModuleConfig_CannedMessageConfig_msg
+#define meshtastic_ModuleConfig_AmbientLightingConfig_fields &meshtastic_ModuleConfig_AmbientLightingConfig_msg
+#define meshtastic_RemoteHardwarePin_fields &meshtastic_RemoteHardwarePin_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_MODULE_CONFIG_PB_H_MAX_SIZE meshtastic_ModuleConfig_size
+#define meshtastic_ModuleConfig_AmbientLightingConfig_size 14
+#define meshtastic_ModuleConfig_AudioConfig_size 19
+#define meshtastic_ModuleConfig_CannedMessageConfig_size 49
+#define meshtastic_ModuleConfig_DetectionSensorConfig_size 44
+#define meshtastic_ModuleConfig_ExternalNotificationConfig_size 42
+#define meshtastic_ModuleConfig_MQTTConfig_size  254
+#define meshtastic_ModuleConfig_MapReportSettings_size 12
+#define meshtastic_ModuleConfig_NeighborInfoConfig_size 8
+#define meshtastic_ModuleConfig_PaxcounterConfig_size 8
+#define meshtastic_ModuleConfig_RangeTestConfig_size 10
+#define meshtastic_ModuleConfig_RemoteHardwareConfig_size 96
+#define meshtastic_ModuleConfig_SerialConfig_size 28
+#define meshtastic_ModuleConfig_StoreForwardConfig_size 22
+#define meshtastic_ModuleConfig_TelemetryConfig_size 36
+#define meshtastic_ModuleConfig_size             257
+#define meshtastic_RemoteHardwarePin_size        21
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/mqtt.pb.cpp

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

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

@@ -0,0 +1,130 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_MQTT_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_MQTT_PB_H_INCLUDED
+#include <pb.h>
+#include "meshtastic/config.pb.h"
+#include "meshtastic/mesh.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+/* This message wraps a MeshPacket with extra metadata about the sender and how it arrived. */
+typedef struct _meshtastic_ServiceEnvelope {
+    /* The (probably encrypted) packet */
+    struct _meshtastic_MeshPacket *packet;
+    /* The global channel ID it was sent on */
+    char *channel_id;
+    /* The sending gateway node ID. Can we use this to authenticate/prevent fake
+ nodeid impersonation for senders? - i.e. use gateway/mesh id (which is authenticated) + local node id as
+ the globally trusted nodenum */
+    char *gateway_id;
+} meshtastic_ServiceEnvelope;
+
+/* Information about a node intended to be reported unencrypted to a map using MQTT. */
+typedef struct _meshtastic_MapReport {
+    /* A full name for this user, i.e. "Kevin Hester" */
+    char long_name[40];
+    /* A VERY short name, ideally two characters.
+ Suitable for a tiny OLED screen */
+    char short_name[5];
+    /* Role of the node that applies specific settings for a particular use-case */
+    meshtastic_Config_DeviceConfig_Role role;
+    /* Hardware model of the node, i.e. T-Beam, Heltec V3, etc... */
+    meshtastic_HardwareModel hw_model;
+    /* Device firmware version string */
+    char firmware_version[18];
+    /* The region code for the radio (US, CN, EU433, etc...) */
+    meshtastic_Config_LoRaConfig_RegionCode region;
+    /* Modem preset used by the radio (LongFast, MediumSlow, etc...) */
+    meshtastic_Config_LoRaConfig_ModemPreset modem_preset;
+    /* Whether the node has a channel with default PSK and name (LongFast, MediumSlow, etc...)
+ and it uses the default frequency slot given the region and modem preset. */
+    bool has_default_channel;
+    /* Latitude: multiply by 1e-7 to get degrees in floating point */
+    int32_t latitude_i;
+    /* Longitude: multiply by 1e-7 to get degrees in floating point */
+    int32_t longitude_i;
+    /* Altitude in meters above MSL */
+    int32_t altitude;
+    /* Indicates the bits of precision for latitude and longitude set by the sending node */
+    uint32_t position_precision;
+    /* Number of online nodes (heard in the last 2 hours) this node has in its list that were received locally (not via MQTT) */
+    uint16_t num_online_local_nodes;
+} meshtastic_MapReport;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define meshtastic_ServiceEnvelope_init_default  {NULL, NULL, NULL}
+#define meshtastic_MapReport_init_default        {"", "", _meshtastic_Config_DeviceConfig_Role_MIN, _meshtastic_HardwareModel_MIN, "", _meshtastic_Config_LoRaConfig_RegionCode_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, 0, 0}
+#define meshtastic_ServiceEnvelope_init_zero     {NULL, NULL, NULL}
+#define meshtastic_MapReport_init_zero           {"", "", _meshtastic_Config_DeviceConfig_Role_MIN, _meshtastic_HardwareModel_MIN, "", _meshtastic_Config_LoRaConfig_RegionCode_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, 0, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_ServiceEnvelope_packet_tag    1
+#define meshtastic_ServiceEnvelope_channel_id_tag 2
+#define meshtastic_ServiceEnvelope_gateway_id_tag 3
+#define meshtastic_MapReport_long_name_tag       1
+#define meshtastic_MapReport_short_name_tag      2
+#define meshtastic_MapReport_role_tag            3
+#define meshtastic_MapReport_hw_model_tag        4
+#define meshtastic_MapReport_firmware_version_tag 5
+#define meshtastic_MapReport_region_tag          6
+#define meshtastic_MapReport_modem_preset_tag    7
+#define meshtastic_MapReport_has_default_channel_tag 8
+#define meshtastic_MapReport_latitude_i_tag      9
+#define meshtastic_MapReport_longitude_i_tag     10
+#define meshtastic_MapReport_altitude_tag        11
+#define meshtastic_MapReport_position_precision_tag 12
+#define meshtastic_MapReport_num_online_local_nodes_tag 13
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_ServiceEnvelope_FIELDLIST(X, a) \
+X(a, POINTER,  OPTIONAL, MESSAGE,  packet,            1) \
+X(a, POINTER,  SINGULAR, STRING,   channel_id,        2) \
+X(a, POINTER,  SINGULAR, STRING,   gateway_id,        3)
+#define meshtastic_ServiceEnvelope_CALLBACK NULL
+#define meshtastic_ServiceEnvelope_DEFAULT NULL
+#define meshtastic_ServiceEnvelope_packet_MSGTYPE meshtastic_MeshPacket
+
+#define meshtastic_MapReport_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, STRING,   long_name,         1) \
+X(a, STATIC,   SINGULAR, STRING,   short_name,        2) \
+X(a, STATIC,   SINGULAR, UENUM,    role,              3) \
+X(a, STATIC,   SINGULAR, UENUM,    hw_model,          4) \
+X(a, STATIC,   SINGULAR, STRING,   firmware_version,   5) \
+X(a, STATIC,   SINGULAR, UENUM,    region,            6) \
+X(a, STATIC,   SINGULAR, UENUM,    modem_preset,      7) \
+X(a, STATIC,   SINGULAR, BOOL,     has_default_channel,   8) \
+X(a, STATIC,   SINGULAR, SFIXED32, latitude_i,        9) \
+X(a, STATIC,   SINGULAR, SFIXED32, longitude_i,      10) \
+X(a, STATIC,   SINGULAR, INT32,    altitude,         11) \
+X(a, STATIC,   SINGULAR, UINT32,   position_precision,  12) \
+X(a, STATIC,   SINGULAR, UINT32,   num_online_local_nodes,  13)
+#define meshtastic_MapReport_CALLBACK NULL
+#define meshtastic_MapReport_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_ServiceEnvelope_msg;
+extern const pb_msgdesc_t meshtastic_MapReport_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_ServiceEnvelope_fields &meshtastic_ServiceEnvelope_msg
+#define meshtastic_MapReport_fields &meshtastic_MapReport_msg
+
+/* Maximum encoded size of messages (where known) */
+/* meshtastic_ServiceEnvelope_size depends on runtime parameters */
+#define MESHTASTIC_MESHTASTIC_MQTT_PB_H_MAX_SIZE meshtastic_MapReport_size
+#define meshtastic_MapReport_size                108
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/paxcount.pb.cpp

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

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

@@ -0,0 +1,58 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_PAXCOUNT_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_PAXCOUNT_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 */
+/* TODO: REPLACE */
+typedef struct _meshtastic_Paxcount {
+    /* seen Wifi devices */
+    uint32_t wifi;
+    /* Seen BLE devices */
+    uint32_t ble;
+    /* Uptime in seconds */
+    uint32_t uptime;
+} meshtastic_Paxcount;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define meshtastic_Paxcount_init_default         {0, 0, 0}
+#define meshtastic_Paxcount_init_zero            {0, 0, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_Paxcount_wifi_tag             1
+#define meshtastic_Paxcount_ble_tag              2
+#define meshtastic_Paxcount_uptime_tag           3
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_Paxcount_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   wifi,              1) \
+X(a, STATIC,   SINGULAR, UINT32,   ble,               2) \
+X(a, STATIC,   SINGULAR, UINT32,   uptime,            3)
+#define meshtastic_Paxcount_CALLBACK NULL
+#define meshtastic_Paxcount_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_Paxcount_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_Paxcount_fields &meshtastic_Paxcount_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_PAXCOUNT_PB_H_MAX_SIZE meshtastic_Paxcount_size
+#define meshtastic_Paxcount_size                 18
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/portnums.pb.cpp

@@ -0,0 +1,10 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#include "meshtastic/portnums.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+
+

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

@@ -0,0 +1,152 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_PORTNUMS_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_PORTNUMS_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+/* For any new 'apps' that run on the device or via sister apps on phones/PCs they should pick and use a
+ unique 'portnum' for their application.
+ If you are making a new app using meshtastic, please send in a pull request to add your 'portnum' to this
+ master table.
+ PortNums should be assigned in the following range:
+ 0-63   Core Meshtastic use, do not use for third party apps
+ 64-127 Registered 3rd party apps, send in a pull request that adds a new entry to portnums.proto to  register your application
+ 256-511 Use one of these portnums for your private applications that you don't want to register publically
+ All other values are reserved.
+ Note: This was formerly a Type enum named 'typ' with the same id #
+ We have change to this 'portnum' based scheme for specifying app handlers for particular payloads.
+ This change is backwards compatible by treating the legacy OPAQUE/CLEAR_TEXT values identically. */
+typedef enum _meshtastic_PortNum {
+    /* Deprecated: do not use in new code (formerly called OPAQUE)
+ A message sent from a device outside of the mesh, in a form the mesh does not understand
+ NOTE: This must be 0, because it is documented in IMeshService.aidl to be so
+ ENCODING: binary undefined */
+    meshtastic_PortNum_UNKNOWN_APP = 0,
+    /* A simple UTF-8 text message, which even the little micros in the mesh
+ can understand and show on their screen eventually in some circumstances
+ even signal might send messages in this form (see below)
+ ENCODING: UTF-8 Plaintext (?) */
+    meshtastic_PortNum_TEXT_MESSAGE_APP = 1,
+    /* Reserved for built-in GPIO/example app.
+ See remote_hardware.proto/HardwareMessage for details on the message sent/received to this port number
+ ENCODING: Protobuf */
+    meshtastic_PortNum_REMOTE_HARDWARE_APP = 2,
+    /* The built-in position messaging app.
+ Payload is a Position message.
+ ENCODING: Protobuf */
+    meshtastic_PortNum_POSITION_APP = 3,
+    /* The built-in user info app.
+ Payload is a User message.
+ ENCODING: Protobuf */
+    meshtastic_PortNum_NODEINFO_APP = 4,
+    /* Protocol control packets for mesh protocol use.
+ Payload is a Routing message.
+ ENCODING: Protobuf */
+    meshtastic_PortNum_ROUTING_APP = 5,
+    /* Admin control packets.
+ Payload is a AdminMessage message.
+ ENCODING: Protobuf */
+    meshtastic_PortNum_ADMIN_APP = 6,
+    /* Compressed TEXT_MESSAGE payloads.
+ ENCODING: UTF-8 Plaintext (?) with Unishox2 Compression
+ NOTE: The Device Firmware converts a TEXT_MESSAGE_APP to TEXT_MESSAGE_COMPRESSED_APP if the compressed
+ payload is shorter. There's no need for app developers to do this themselves. Also the firmware will decompress
+ any incoming TEXT_MESSAGE_COMPRESSED_APP payload and convert to TEXT_MESSAGE_APP. */
+    meshtastic_PortNum_TEXT_MESSAGE_COMPRESSED_APP = 7,
+    /* Waypoint payloads.
+ Payload is a Waypoint message.
+ ENCODING: Protobuf */
+    meshtastic_PortNum_WAYPOINT_APP = 8,
+    /* Audio Payloads.
+ Encapsulated codec2 packets. On 2.4 GHZ Bandwidths only for now
+ ENCODING: codec2 audio frames
+ NOTE: audio frames contain a 3 byte header (0xc0 0xde 0xc2) and a one byte marker for the decompressed bitrate.
+ This marker comes from the 'moduleConfig.audio.bitrate' enum minus one. */
+    meshtastic_PortNum_AUDIO_APP = 9,
+    /* Same as Text Message but originating from Detection Sensor Module.
+ NOTE: This portnum traffic is not sent to the public MQTT starting at firmware version 2.2.9 */
+    meshtastic_PortNum_DETECTION_SENSOR_APP = 10,
+    /* Provides a 'ping' service that replies to any packet it receives.
+ Also serves as a small example module.
+ ENCODING: ASCII Plaintext */
+    meshtastic_PortNum_REPLY_APP = 32,
+    /* Used for the python IP tunnel feature
+ ENCODING: IP Packet. Handled by the python API, firmware ignores this one and pases on. */
+    meshtastic_PortNum_IP_TUNNEL_APP = 33,
+    /* Paxcounter lib included in the firmware
+ ENCODING: protobuf */
+    meshtastic_PortNum_PAXCOUNTER_APP = 34,
+    /* Provides a hardware serial interface to send and receive from the Meshtastic network.
+ Connect to the RX/TX pins of a device with 38400 8N1. Packets received from the Meshtastic
+ network is forwarded to the RX pin while sending a packet to TX will go out to the Mesh network.
+ Maximum packet size of 240 bytes.
+ Module is disabled by default can be turned on by setting SERIAL_MODULE_ENABLED = 1 in SerialPlugh.cpp.
+ ENCODING: binary undefined */
+    meshtastic_PortNum_SERIAL_APP = 64,
+    /* STORE_FORWARD_APP (Work in Progress)
+ Maintained by Jm Casler (MC Hamster) : jm@casler.org
+ ENCODING: Protobuf */
+    meshtastic_PortNum_STORE_FORWARD_APP = 65,
+    /* Optional port for messages for the range test module.
+ ENCODING: ASCII Plaintext
+ NOTE: This portnum traffic is not sent to the public MQTT starting at firmware version 2.2.9 */
+    meshtastic_PortNum_RANGE_TEST_APP = 66,
+    /* Provides a format to send and receive telemetry data from the Meshtastic network.
+ Maintained by Charles Crossan (crossan007) : crossan007@gmail.com
+ ENCODING: Protobuf */
+    meshtastic_PortNum_TELEMETRY_APP = 67,
+    /* Experimental tools for estimating node position without a GPS
+ Maintained by Github user a-f-G-U-C (a Meshtastic contributor)
+ Project files at https://github.com/a-f-G-U-C/Meshtastic-ZPS
+ ENCODING: arrays of int64 fields */
+    meshtastic_PortNum_ZPS_APP = 68,
+    /* Used to let multiple instances of Linux native applications communicate
+ as if they did using their LoRa chip.
+ Maintained by GitHub user GUVWAF.
+ Project files at https://github.com/GUVWAF/Meshtasticator
+ ENCODING: Protobuf (?) */
+    meshtastic_PortNum_SIMULATOR_APP = 69,
+    /* Provides a traceroute functionality to show the route a packet towards
+ a certain destination would take on the mesh.
+ ENCODING: Protobuf */
+    meshtastic_PortNum_TRACEROUTE_APP = 70,
+    /* Aggregates edge info for the network by sending out a list of each node's neighbors
+ ENCODING: Protobuf */
+    meshtastic_PortNum_NEIGHBORINFO_APP = 71,
+    /* ATAK Plugin
+ Portnum for payloads from the official Meshtastic ATAK plugin */
+    meshtastic_PortNum_ATAK_PLUGIN = 72,
+    /* Provides unencrypted information about a node for consumption by a map via MQTT */
+    meshtastic_PortNum_MAP_REPORT_APP = 73,
+    /* Private applications should use portnums >= 256.
+ To simplify initial development and testing you can use "PRIVATE_APP"
+ in your code without needing to rebuild protobuf files (via [regen-protos.sh](https://github.com/meshtastic/firmware/blob/master/bin/regen-protos.sh)) */
+    meshtastic_PortNum_PRIVATE_APP = 256,
+    /* ATAK Forwarder Module https://github.com/paulmandal/atak-forwarder
+ ENCODING: libcotshrink */
+    meshtastic_PortNum_ATAK_FORWARDER = 257,
+    /* Currently we limit port nums to no higher than this value */
+    meshtastic_PortNum_MAX = 511
+} meshtastic_PortNum;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_PortNum_MIN meshtastic_PortNum_UNKNOWN_APP
+#define _meshtastic_PortNum_MAX meshtastic_PortNum_MAX
+#define _meshtastic_PortNum_ARRAYSIZE ((meshtastic_PortNum)(meshtastic_PortNum_MAX+1))
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/remote_hardware.pb.cpp

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

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

@@ -0,0 +1,94 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_REMOTE_HARDWARE_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_REMOTE_HARDWARE_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+/* TODO: REPLACE */
+typedef enum _meshtastic_HardwareMessage_Type {
+    /* Unset/unused */
+    meshtastic_HardwareMessage_Type_UNSET = 0,
+    /* Set gpio gpios based on gpio_mask/gpio_value */
+    meshtastic_HardwareMessage_Type_WRITE_GPIOS = 1,
+    /* We are now interested in watching the gpio_mask gpios.
+ If the selected gpios change, please broadcast GPIOS_CHANGED.
+ Will implicitly change the gpios requested to be INPUT gpios. */
+    meshtastic_HardwareMessage_Type_WATCH_GPIOS = 2,
+    /* The gpios listed in gpio_mask have changed, the new values are listed in gpio_value */
+    meshtastic_HardwareMessage_Type_GPIOS_CHANGED = 3,
+    /* Read the gpios specified in gpio_mask, send back a READ_GPIOS_REPLY reply with gpio_value populated */
+    meshtastic_HardwareMessage_Type_READ_GPIOS = 4,
+    /* A reply to READ_GPIOS. gpio_mask and gpio_value will be populated */
+    meshtastic_HardwareMessage_Type_READ_GPIOS_REPLY = 5
+} meshtastic_HardwareMessage_Type;
+
+/* Struct definitions */
+/* An example app to show off the module system. This message is used for
+ REMOTE_HARDWARE_APP PortNums.
+ Also provides easy remote access to any GPIO.
+ In the future other remote hardware operations can be added based on user interest
+ (i.e. serial output, spi/i2c input/output).
+ FIXME - currently this feature is turned on by default which is dangerous
+ because no security yet (beyond the channel mechanism).
+ It should be off by default and then protected based on some TBD mechanism
+ (a special channel once multichannel support is included?) */
+typedef struct _meshtastic_HardwareMessage {
+    /* What type of HardwareMessage is this? */
+    meshtastic_HardwareMessage_Type type;
+    /* What gpios are we changing. Not used for all MessageTypes, see MessageType for details */
+    uint64_t gpio_mask;
+    /* For gpios that were listed in gpio_mask as valid, what are the signal levels for those gpios.
+ Not used for all MessageTypes, see MessageType for details */
+    uint64_t gpio_value;
+} meshtastic_HardwareMessage;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_HardwareMessage_Type_MIN meshtastic_HardwareMessage_Type_UNSET
+#define _meshtastic_HardwareMessage_Type_MAX meshtastic_HardwareMessage_Type_READ_GPIOS_REPLY
+#define _meshtastic_HardwareMessage_Type_ARRAYSIZE ((meshtastic_HardwareMessage_Type)(meshtastic_HardwareMessage_Type_READ_GPIOS_REPLY+1))
+
+#define meshtastic_HardwareMessage_type_ENUMTYPE meshtastic_HardwareMessage_Type
+
+
+/* Initializer values for message structs */
+#define meshtastic_HardwareMessage_init_default  {_meshtastic_HardwareMessage_Type_MIN, 0, 0}
+#define meshtastic_HardwareMessage_init_zero     {_meshtastic_HardwareMessage_Type_MIN, 0, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_HardwareMessage_type_tag      1
+#define meshtastic_HardwareMessage_gpio_mask_tag 2
+#define meshtastic_HardwareMessage_gpio_value_tag 3
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_HardwareMessage_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    type,              1) \
+X(a, STATIC,   SINGULAR, UINT64,   gpio_mask,         2) \
+X(a, STATIC,   SINGULAR, UINT64,   gpio_value,        3)
+#define meshtastic_HardwareMessage_CALLBACK NULL
+#define meshtastic_HardwareMessage_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_HardwareMessage_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_HardwareMessage_fields &meshtastic_HardwareMessage_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_REMOTE_HARDWARE_PB_H_MAX_SIZE meshtastic_HardwareMessage_size
+#define meshtastic_HardwareMessage_size          24
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/rtttl.pb.cpp

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

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

@@ -0,0 +1,50 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_RTTTL_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_RTTTL_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 */
+/* Canned message module configuration. */
+typedef struct _meshtastic_RTTTLConfig {
+    /* Ringtone for PWM Buzzer in RTTTL Format. */
+    char ringtone[230];
+} meshtastic_RTTTLConfig;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define meshtastic_RTTTLConfig_init_default      {""}
+#define meshtastic_RTTTLConfig_init_zero         {""}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_RTTTLConfig_ringtone_tag      1
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_RTTTLConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, STRING,   ringtone,          1)
+#define meshtastic_RTTTLConfig_CALLBACK NULL
+#define meshtastic_RTTTLConfig_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_RTTTLConfig_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_RTTTLConfig_fields &meshtastic_RTTTLConfig_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_RTTTL_PB_H_MAX_SIZE meshtastic_RTTTLConfig_size
+#define meshtastic_RTTTLConfig_size              232
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/storeforward.pb.cpp

@@ -0,0 +1,22 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#include "meshtastic/storeforward.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_StoreAndForward, meshtastic_StoreAndForward, AUTO)
+
+
+PB_BIND(meshtastic_StoreAndForward_Statistics, meshtastic_StoreAndForward_Statistics, AUTO)
+
+
+PB_BIND(meshtastic_StoreAndForward_History, meshtastic_StoreAndForward_History, AUTO)
+
+
+PB_BIND(meshtastic_StoreAndForward_Heartbeat, meshtastic_StoreAndForward_Heartbeat, AUTO)
+
+
+
+

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

@@ -0,0 +1,220 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_STOREFORWARD_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_STOREFORWARD_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+/* 001 - 063 = From Router
+ 064 - 127 = From Client */
+typedef enum _meshtastic_StoreAndForward_RequestResponse {
+    /* Unset/unused */
+    meshtastic_StoreAndForward_RequestResponse_UNSET = 0,
+    /* Router is an in error state. */
+    meshtastic_StoreAndForward_RequestResponse_ROUTER_ERROR = 1,
+    /* Router heartbeat */
+    meshtastic_StoreAndForward_RequestResponse_ROUTER_HEARTBEAT = 2,
+    /* Router has requested the client respond. This can work as a
+ "are you there" message. */
+    meshtastic_StoreAndForward_RequestResponse_ROUTER_PING = 3,
+    /* The response to a "Ping" */
+    meshtastic_StoreAndForward_RequestResponse_ROUTER_PONG = 4,
+    /* Router is currently busy. Please try again later. */
+    meshtastic_StoreAndForward_RequestResponse_ROUTER_BUSY = 5,
+    /* Router is responding to a request for history. */
+    meshtastic_StoreAndForward_RequestResponse_ROUTER_HISTORY = 6,
+    /* Router is responding to a request for stats. */
+    meshtastic_StoreAndForward_RequestResponse_ROUTER_STATS = 7,
+    /* Router sends a text message from its history that was a direct message. */
+    meshtastic_StoreAndForward_RequestResponse_ROUTER_TEXT_DIRECT = 8,
+    /* Router sends a text message from its history that was a broadcast. */
+    meshtastic_StoreAndForward_RequestResponse_ROUTER_TEXT_BROADCAST = 9,
+    /* Client is an in error state. */
+    meshtastic_StoreAndForward_RequestResponse_CLIENT_ERROR = 64,
+    /* Client has requested a replay from the router. */
+    meshtastic_StoreAndForward_RequestResponse_CLIENT_HISTORY = 65,
+    /* Client has requested stats from the router. */
+    meshtastic_StoreAndForward_RequestResponse_CLIENT_STATS = 66,
+    /* Client has requested the router respond. This can work as a
+ "are you there" message. */
+    meshtastic_StoreAndForward_RequestResponse_CLIENT_PING = 67,
+    /* The response to a "Ping" */
+    meshtastic_StoreAndForward_RequestResponse_CLIENT_PONG = 68,
+    /* Client has requested that the router abort processing the client's request */
+    meshtastic_StoreAndForward_RequestResponse_CLIENT_ABORT = 106
+} meshtastic_StoreAndForward_RequestResponse;
+
+/* Struct definitions */
+/* TODO: REPLACE */
+typedef struct _meshtastic_StoreAndForward_Statistics {
+    /* Number of messages we have ever seen */
+    uint32_t messages_total;
+    /* Number of messages we have currently saved our history. */
+    uint32_t messages_saved;
+    /* Maximum number of messages we will save */
+    uint32_t messages_max;
+    /* Router uptime in seconds */
+    uint32_t up_time;
+    /* Number of times any client sent a request to the S&F. */
+    uint32_t requests;
+    /* Number of times the history was requested. */
+    uint32_t requests_history;
+    /* Is the heartbeat enabled on the server? */
+    bool heartbeat;
+    /* Maximum number of messages the server will return. */
+    uint32_t return_max;
+    /* Maximum history window in minutes the server will return messages from. */
+    uint32_t return_window;
+} meshtastic_StoreAndForward_Statistics;
+
+/* TODO: REPLACE */
+typedef struct _meshtastic_StoreAndForward_History {
+    /* Number of that will be sent to the client */
+    uint32_t history_messages;
+    /* The window of messages that was used to filter the history client requested */
+    uint32_t window;
+    /* Index in the packet history of the last message sent in a previous request to the server.
+ Will be sent to the client before sending the history and can be set in a subsequent request to avoid getting packets the server already sent to the client. */
+    uint32_t last_request;
+} meshtastic_StoreAndForward_History;
+
+/* TODO: REPLACE */
+typedef struct _meshtastic_StoreAndForward_Heartbeat {
+    /* Period in seconds that the heartbeat is sent out that will be sent to the client */
+    uint32_t period;
+    /* If set, this is not the primary Store & Forward router on the mesh */
+    uint32_t secondary;
+} meshtastic_StoreAndForward_Heartbeat;
+
+typedef PB_BYTES_ARRAY_T(237) meshtastic_StoreAndForward_text_t;
+/* TODO: REPLACE */
+typedef struct _meshtastic_StoreAndForward {
+    /* TODO: REPLACE */
+    meshtastic_StoreAndForward_RequestResponse rr;
+    pb_size_t which_variant;
+    union {
+        /* TODO: REPLACE */
+        meshtastic_StoreAndForward_Statistics stats;
+        /* TODO: REPLACE */
+        meshtastic_StoreAndForward_History history;
+        /* TODO: REPLACE */
+        meshtastic_StoreAndForward_Heartbeat heartbeat;
+        /* Text from history message. */
+        meshtastic_StoreAndForward_text_t text;
+    } variant;
+} meshtastic_StoreAndForward;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_StoreAndForward_RequestResponse_MIN meshtastic_StoreAndForward_RequestResponse_UNSET
+#define _meshtastic_StoreAndForward_RequestResponse_MAX meshtastic_StoreAndForward_RequestResponse_CLIENT_ABORT
+#define _meshtastic_StoreAndForward_RequestResponse_ARRAYSIZE ((meshtastic_StoreAndForward_RequestResponse)(meshtastic_StoreAndForward_RequestResponse_CLIENT_ABORT+1))
+
+#define meshtastic_StoreAndForward_rr_ENUMTYPE meshtastic_StoreAndForward_RequestResponse
+
+
+
+
+
+/* Initializer values for message structs */
+#define meshtastic_StoreAndForward_init_default  {_meshtastic_StoreAndForward_RequestResponse_MIN, 0, {meshtastic_StoreAndForward_Statistics_init_default}}
+#define meshtastic_StoreAndForward_Statistics_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_StoreAndForward_History_init_default {0, 0, 0}
+#define meshtastic_StoreAndForward_Heartbeat_init_default {0, 0}
+#define meshtastic_StoreAndForward_init_zero     {_meshtastic_StoreAndForward_RequestResponse_MIN, 0, {meshtastic_StoreAndForward_Statistics_init_zero}}
+#define meshtastic_StoreAndForward_Statistics_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_StoreAndForward_History_init_zero {0, 0, 0}
+#define meshtastic_StoreAndForward_Heartbeat_init_zero {0, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_StoreAndForward_Statistics_messages_total_tag 1
+#define meshtastic_StoreAndForward_Statistics_messages_saved_tag 2
+#define meshtastic_StoreAndForward_Statistics_messages_max_tag 3
+#define meshtastic_StoreAndForward_Statistics_up_time_tag 4
+#define meshtastic_StoreAndForward_Statistics_requests_tag 5
+#define meshtastic_StoreAndForward_Statistics_requests_history_tag 6
+#define meshtastic_StoreAndForward_Statistics_heartbeat_tag 7
+#define meshtastic_StoreAndForward_Statistics_return_max_tag 8
+#define meshtastic_StoreAndForward_Statistics_return_window_tag 9
+#define meshtastic_StoreAndForward_History_history_messages_tag 1
+#define meshtastic_StoreAndForward_History_window_tag 2
+#define meshtastic_StoreAndForward_History_last_request_tag 3
+#define meshtastic_StoreAndForward_Heartbeat_period_tag 1
+#define meshtastic_StoreAndForward_Heartbeat_secondary_tag 2
+#define meshtastic_StoreAndForward_rr_tag        1
+#define meshtastic_StoreAndForward_stats_tag     2
+#define meshtastic_StoreAndForward_history_tag   3
+#define meshtastic_StoreAndForward_heartbeat_tag 4
+#define meshtastic_StoreAndForward_text_tag      5
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_StoreAndForward_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    rr,                1) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,stats,variant.stats),   2) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,history,variant.history),   3) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,heartbeat,variant.heartbeat),   4) \
+X(a, STATIC,   ONEOF,    BYTES,    (variant,text,variant.text),   5)
+#define meshtastic_StoreAndForward_CALLBACK NULL
+#define meshtastic_StoreAndForward_DEFAULT NULL
+#define meshtastic_StoreAndForward_variant_stats_MSGTYPE meshtastic_StoreAndForward_Statistics
+#define meshtastic_StoreAndForward_variant_history_MSGTYPE meshtastic_StoreAndForward_History
+#define meshtastic_StoreAndForward_variant_heartbeat_MSGTYPE meshtastic_StoreAndForward_Heartbeat
+
+#define meshtastic_StoreAndForward_Statistics_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   messages_total,    1) \
+X(a, STATIC,   SINGULAR, UINT32,   messages_saved,    2) \
+X(a, STATIC,   SINGULAR, UINT32,   messages_max,      3) \
+X(a, STATIC,   SINGULAR, UINT32,   up_time,           4) \
+X(a, STATIC,   SINGULAR, UINT32,   requests,          5) \
+X(a, STATIC,   SINGULAR, UINT32,   requests_history,   6) \
+X(a, STATIC,   SINGULAR, BOOL,     heartbeat,         7) \
+X(a, STATIC,   SINGULAR, UINT32,   return_max,        8) \
+X(a, STATIC,   SINGULAR, UINT32,   return_window,     9)
+#define meshtastic_StoreAndForward_Statistics_CALLBACK NULL
+#define meshtastic_StoreAndForward_Statistics_DEFAULT NULL
+
+#define meshtastic_StoreAndForward_History_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   history_messages,   1) \
+X(a, STATIC,   SINGULAR, UINT32,   window,            2) \
+X(a, STATIC,   SINGULAR, UINT32,   last_request,      3)
+#define meshtastic_StoreAndForward_History_CALLBACK NULL
+#define meshtastic_StoreAndForward_History_DEFAULT NULL
+
+#define meshtastic_StoreAndForward_Heartbeat_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   period,            1) \
+X(a, STATIC,   SINGULAR, UINT32,   secondary,         2)
+#define meshtastic_StoreAndForward_Heartbeat_CALLBACK NULL
+#define meshtastic_StoreAndForward_Heartbeat_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_StoreAndForward_msg;
+extern const pb_msgdesc_t meshtastic_StoreAndForward_Statistics_msg;
+extern const pb_msgdesc_t meshtastic_StoreAndForward_History_msg;
+extern const pb_msgdesc_t meshtastic_StoreAndForward_Heartbeat_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_StoreAndForward_fields &meshtastic_StoreAndForward_msg
+#define meshtastic_StoreAndForward_Statistics_fields &meshtastic_StoreAndForward_Statistics_msg
+#define meshtastic_StoreAndForward_History_fields &meshtastic_StoreAndForward_History_msg
+#define meshtastic_StoreAndForward_Heartbeat_fields &meshtastic_StoreAndForward_Heartbeat_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_STOREFORWARD_PB_H_MAX_SIZE meshtastic_StoreAndForward_size
+#define meshtastic_StoreAndForward_Heartbeat_size 12
+#define meshtastic_StoreAndForward_History_size  18
+#define meshtastic_StoreAndForward_Statistics_size 50
+#define meshtastic_StoreAndForward_size          242
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

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

@@ -0,0 +1,25 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#include "meshtastic/telemetry.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_DeviceMetrics, meshtastic_DeviceMetrics, AUTO)
+
+
+PB_BIND(meshtastic_EnvironmentMetrics, meshtastic_EnvironmentMetrics, AUTO)
+
+
+PB_BIND(meshtastic_PowerMetrics, meshtastic_PowerMetrics, AUTO)
+
+
+PB_BIND(meshtastic_AirQualityMetrics, meshtastic_AirQualityMetrics, AUTO)
+
+
+PB_BIND(meshtastic_Telemetry, meshtastic_Telemetry, AUTO)
+
+
+
+

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

@@ -0,0 +1,294 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_TELEMETRY_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_TELEMETRY_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+/* Supported I2C Sensors for telemetry in Meshtastic */
+typedef enum _meshtastic_TelemetrySensorType {
+    /* No external telemetry sensor explicitly set */
+    meshtastic_TelemetrySensorType_SENSOR_UNSET = 0,
+    /* High accuracy temperature, pressure, humidity */
+    meshtastic_TelemetrySensorType_BME280 = 1,
+    /* High accuracy temperature, pressure, humidity, and air resistance */
+    meshtastic_TelemetrySensorType_BME680 = 2,
+    /* Very high accuracy temperature */
+    meshtastic_TelemetrySensorType_MCP9808 = 3,
+    /* Moderate accuracy current and voltage */
+    meshtastic_TelemetrySensorType_INA260 = 4,
+    /* Moderate accuracy current and voltage */
+    meshtastic_TelemetrySensorType_INA219 = 5,
+    /* High accuracy temperature and pressure */
+    meshtastic_TelemetrySensorType_BMP280 = 6,
+    /* High accuracy temperature and humidity */
+    meshtastic_TelemetrySensorType_SHTC3 = 7,
+    /* High accuracy pressure */
+    meshtastic_TelemetrySensorType_LPS22 = 8,
+    /* 3-Axis magnetic sensor */
+    meshtastic_TelemetrySensorType_QMC6310 = 9,
+    /* 6-Axis inertial measurement sensor */
+    meshtastic_TelemetrySensorType_QMI8658 = 10,
+    /* 3-Axis magnetic sensor */
+    meshtastic_TelemetrySensorType_QMC5883L = 11,
+    /* High accuracy temperature and humidity */
+    meshtastic_TelemetrySensorType_SHT31 = 12,
+    /* PM2.5 air quality sensor */
+    meshtastic_TelemetrySensorType_PMSA003I = 13,
+    /* INA3221 3 Channel Voltage / Current Sensor */
+    meshtastic_TelemetrySensorType_INA3221 = 14,
+    /* BMP085/BMP180 High accuracy temperature and pressure (older Version of BMP280) */
+    meshtastic_TelemetrySensorType_BMP085 = 15
+} meshtastic_TelemetrySensorType;
+
+/* Struct definitions */
+/* Key native device metrics such as battery level */
+typedef struct _meshtastic_DeviceMetrics {
+    /* 0-100 (>100 means powered) */
+    uint32_t battery_level;
+    /* Voltage measured */
+    float voltage;
+    /* Utilization for the current channel, including well formed TX, RX and malformed RX (aka noise). */
+    float channel_utilization;
+    /* Percent of airtime for transmission used within the last hour. */
+    float air_util_tx;
+    /* How long the device has been running since the last reboot (in seconds) */
+    uint32_t uptime_seconds;
+} meshtastic_DeviceMetrics;
+
+/* Weather station or other environmental metrics */
+typedef struct _meshtastic_EnvironmentMetrics {
+    /* Temperature measured */
+    float temperature;
+    /* Relative humidity percent measured */
+    float relative_humidity;
+    /* Barometric pressure in hPA measured */
+    float barometric_pressure;
+    /* Gas resistance in MOhm measured */
+    float gas_resistance;
+    /* Voltage measured (To be depreciated in favor of PowerMetrics in Meshtastic 3.x) */
+    float voltage;
+    /* Current measured (To be depreciated in favor of PowerMetrics in Meshtastic 3.x) */
+    float current;
+    /* relative scale IAQ value as measured by Bosch BME680 . value 0-500.
+ Belongs to Air Quality but is not particle but VOC measurement. Other VOC values can also be put in here. */
+    uint16_t iaq;
+} meshtastic_EnvironmentMetrics;
+
+/* Power Metrics (voltage / current / etc) */
+typedef struct _meshtastic_PowerMetrics {
+    /* Voltage (Ch1) */
+    float ch1_voltage;
+    /* Current (Ch1) */
+    float ch1_current;
+    /* Voltage (Ch2) */
+    float ch2_voltage;
+    /* Current (Ch2) */
+    float ch2_current;
+    /* Voltage (Ch3) */
+    float ch3_voltage;
+    /* Current (Ch3) */
+    float ch3_current;
+} meshtastic_PowerMetrics;
+
+/* 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 {
+    /* Seconds since 1970 - or 0 for unknown/unset */
+    uint32_t time;
+    pb_size_t which_variant;
+    union {
+        /* Key native device metrics such as battery level */
+        meshtastic_DeviceMetrics device_metrics;
+        /* Weather station or other environmental metrics */
+        meshtastic_EnvironmentMetrics environment_metrics;
+        /* Air quality metrics */
+        meshtastic_AirQualityMetrics air_quality_metrics;
+        /* Power Metrics */
+        meshtastic_PowerMetrics power_metrics;
+    } variant;
+} meshtastic_Telemetry;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_TelemetrySensorType_MIN meshtastic_TelemetrySensorType_SENSOR_UNSET
+#define _meshtastic_TelemetrySensorType_MAX meshtastic_TelemetrySensorType_BMP085
+#define _meshtastic_TelemetrySensorType_ARRAYSIZE ((meshtastic_TelemetrySensorType)(meshtastic_TelemetrySensorType_BMP085+1))
+
+
+
+
+
+
+
+/* Initializer values for message structs */
+#define meshtastic_DeviceMetrics_init_default    {0, 0, 0, 0, 0}
+#define meshtastic_EnvironmentMetrics_init_default {0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_PowerMetrics_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, 0}
+#define meshtastic_EnvironmentMetrics_init_zero  {0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_PowerMetrics_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) */
+#define meshtastic_DeviceMetrics_battery_level_tag 1
+#define meshtastic_DeviceMetrics_voltage_tag     2
+#define meshtastic_DeviceMetrics_channel_utilization_tag 3
+#define meshtastic_DeviceMetrics_air_util_tx_tag 4
+#define meshtastic_DeviceMetrics_uptime_seconds_tag 5
+#define meshtastic_EnvironmentMetrics_temperature_tag 1
+#define meshtastic_EnvironmentMetrics_relative_humidity_tag 2
+#define meshtastic_EnvironmentMetrics_barometric_pressure_tag 3
+#define meshtastic_EnvironmentMetrics_gas_resistance_tag 4
+#define meshtastic_EnvironmentMetrics_voltage_tag 5
+#define meshtastic_EnvironmentMetrics_current_tag 6
+#define meshtastic_EnvironmentMetrics_iaq_tag    7
+#define meshtastic_PowerMetrics_ch1_voltage_tag  1
+#define meshtastic_PowerMetrics_ch1_current_tag  2
+#define meshtastic_PowerMetrics_ch2_voltage_tag  3
+#define meshtastic_PowerMetrics_ch2_current_tag  4
+#define meshtastic_PowerMetrics_ch3_voltage_tag  5
+#define meshtastic_PowerMetrics_ch3_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
+#define meshtastic_Telemetry_power_metrics_tag   5
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_DeviceMetrics_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   battery_level,     1) \
+X(a, STATIC,   SINGULAR, FLOAT,    voltage,           2) \
+X(a, STATIC,   SINGULAR, FLOAT,    channel_utilization,   3) \
+X(a, STATIC,   SINGULAR, FLOAT,    air_util_tx,       4) \
+X(a, STATIC,   SINGULAR, UINT32,   uptime_seconds,    5)
+#define meshtastic_DeviceMetrics_CALLBACK NULL
+#define meshtastic_DeviceMetrics_DEFAULT NULL
+
+#define meshtastic_EnvironmentMetrics_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, FLOAT,    temperature,       1) \
+X(a, STATIC,   SINGULAR, FLOAT,    relative_humidity,   2) \
+X(a, STATIC,   SINGULAR, FLOAT,    barometric_pressure,   3) \
+X(a, STATIC,   SINGULAR, FLOAT,    gas_resistance,    4) \
+X(a, STATIC,   SINGULAR, FLOAT,    voltage,           5) \
+X(a, STATIC,   SINGULAR, FLOAT,    current,           6) \
+X(a, STATIC,   SINGULAR, UINT32,   iaq,               7)
+#define meshtastic_EnvironmentMetrics_CALLBACK NULL
+#define meshtastic_EnvironmentMetrics_DEFAULT NULL
+
+#define meshtastic_PowerMetrics_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, FLOAT,    ch1_voltage,       1) \
+X(a, STATIC,   SINGULAR, FLOAT,    ch1_current,       2) \
+X(a, STATIC,   SINGULAR, FLOAT,    ch2_voltage,       3) \
+X(a, STATIC,   SINGULAR, FLOAT,    ch2_current,       4) \
+X(a, STATIC,   SINGULAR, FLOAT,    ch3_voltage,       5) \
+X(a, STATIC,   SINGULAR, FLOAT,    ch3_current,       6)
+#define meshtastic_PowerMetrics_CALLBACK NULL
+#define meshtastic_PowerMetrics_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,air_quality_metrics,variant.air_quality_metrics),   4) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,power_metrics,variant.power_metrics),   5)
+#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
+#define meshtastic_Telemetry_variant_power_metrics_MSGTYPE meshtastic_PowerMetrics
+
+extern const pb_msgdesc_t meshtastic_DeviceMetrics_msg;
+extern const pb_msgdesc_t meshtastic_EnvironmentMetrics_msg;
+extern const pb_msgdesc_t meshtastic_PowerMetrics_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_PowerMetrics_fields &meshtastic_PowerMetrics_msg
+#define meshtastic_AirQualityMetrics_fields &meshtastic_AirQualityMetrics_msg
+#define meshtastic_Telemetry_fields &meshtastic_Telemetry_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_TELEMETRY_PB_H_MAX_SIZE meshtastic_Telemetry_size
+#define meshtastic_AirQualityMetrics_size        72
+#define meshtastic_DeviceMetrics_size            27
+#define meshtastic_EnvironmentMetrics_size       34
+#define meshtastic_PowerMetrics_size             30
+#define meshtastic_Telemetry_size                79
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/xmodem.pb.cpp

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

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

@@ -0,0 +1,78 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_XMODEM_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_XMODEM_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _meshtastic_XModem_Control {
+    meshtastic_XModem_Control_NUL = 0,
+    meshtastic_XModem_Control_SOH = 1,
+    meshtastic_XModem_Control_STX = 2,
+    meshtastic_XModem_Control_EOT = 4,
+    meshtastic_XModem_Control_ACK = 6,
+    meshtastic_XModem_Control_NAK = 21,
+    meshtastic_XModem_Control_CAN = 24,
+    meshtastic_XModem_Control_CTRLZ = 26
+} meshtastic_XModem_Control;
+
+/* Struct definitions */
+typedef PB_BYTES_ARRAY_T(128) meshtastic_XModem_buffer_t;
+typedef struct _meshtastic_XModem {
+    meshtastic_XModem_Control control;
+    uint16_t seq;
+    uint16_t crc16;
+    meshtastic_XModem_buffer_t buffer;
+} meshtastic_XModem;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_XModem_Control_MIN meshtastic_XModem_Control_NUL
+#define _meshtastic_XModem_Control_MAX meshtastic_XModem_Control_CTRLZ
+#define _meshtastic_XModem_Control_ARRAYSIZE ((meshtastic_XModem_Control)(meshtastic_XModem_Control_CTRLZ+1))
+
+#define meshtastic_XModem_control_ENUMTYPE meshtastic_XModem_Control
+
+
+/* Initializer values for message structs */
+#define meshtastic_XModem_init_default           {_meshtastic_XModem_Control_MIN, 0, 0, {0, {0}}}
+#define meshtastic_XModem_init_zero              {_meshtastic_XModem_Control_MIN, 0, 0, {0, {0}}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_XModem_control_tag            1
+#define meshtastic_XModem_seq_tag                2
+#define meshtastic_XModem_crc16_tag              3
+#define meshtastic_XModem_buffer_tag             4
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_XModem_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    control,           1) \
+X(a, STATIC,   SINGULAR, UINT32,   seq,               2) \
+X(a, STATIC,   SINGULAR, UINT32,   crc16,             3) \
+X(a, STATIC,   SINGULAR, BYTES,    buffer,            4)
+#define meshtastic_XModem_CALLBACK NULL
+#define meshtastic_XModem_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_XModem_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_XModem_fields &meshtastic_XModem_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_XMODEM_PB_H_MAX_SIZE meshtastic_XModem_size
+#define meshtastic_XModem_size                   141
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/platform/cubecell/cubecellCryptoEngine.cpp

@@ -0,0 +1,38 @@
+// This is the CryptoEngine for STM32WL, it works also for CubeCell
+
+#include "CryptoEngine.h"
+#include "aes.hpp"
+#include "configuration.h"
+
+class STM32WLCryptoEngine : public CryptoEngine
+{
+  public:
+    STM32WLCryptoEngine() {}
+
+    ~STM32WLCryptoEngine() {}
+
+    /**
+     * Encrypt a packet
+     *
+     * @param bytes is updated in place
+     */
+    virtual void encrypt(uint32_t fromNode, uint64_t packetNum, size_t numBytes, uint8_t *bytes) override
+    {
+        if (key.length > 0) {
+            AES_ctx ctx;
+            initNonce(fromNode, packetNum);
+            AES_init_ctx_iv(&ctx, key.bytes, nonce);
+            AES_CTR_xcrypt_buffer(&ctx, bytes, numBytes);
+        }
+    }
+
+    virtual void decrypt(uint32_t fromNode, uint64_t packetNum, size_t numBytes, uint8_t *bytes) override
+    {
+        // For CTR, the implementation is the same
+        encrypt(fromNode, packetNum, numBytes, bytes);
+    }
+
+  private:
+};
+
+CryptoEngine *crypto = new STM32WLCryptoEngine();