Merge branch 'master' into unify-tft

2025-06-17 10:32:07 +00:00 · 2025-06-10 06:54:34 -05:00 · 2025-06-10 06:54:34 -05:00 · 40d8cbc3b5
commit 40d8cbc3b5
parent d25d513e40 693b11db1d
15 changed files with 200 additions and 32 deletions
--- a/.trunk/trunk.yaml
+++ b/.trunk/trunk.yaml
@ -8,7 +8,7 @@ plugins:
      uri: https://github.com/trunk-io/plugins
 lint:
  enabled:
-    - checkov@3.2.436
+    - checkov@3.2.437
    - renovate@40.42.2
    - prettier@3.5.3
    - trufflehog@3.88.35
@ -16,7 +16,7 @@ lint:
    - bandit@1.8.3
    - trivy@0.63.0
    - taplo@0.9.3
-    - ruff@0.11.12
+    - ruff@0.11.13
    - isort@6.0.1
    - markdownlint@0.45.0
    - oxipng@9.1.5
--- a/boards/ThinkNode-M1.json
+++ b/boards/ThinkNode-M1.json
@ -48,6 +48,6 @@
    "require_upload_port": true,
    "wait_for_upload_port": true
  },
-  "url": "FIXME",
+  "url": "https://www.elecrow.com/thinknode-m1-meshtastic-lora-signal-transceiver-powered-by-nrf52840-with-154-screen-support-gps.html",
  "vendor": "ELECROW"
 }
--- a/boards/heltec_mesh_node_t114.json
+++ b/boards/heltec_mesh_node_t114.json
@ -48,6 +48,6 @@
    "require_upload_port": true,
    "wait_for_upload_port": true
  },
-  "url": "FIXME",
+  "url": "https://heltec.org/project/mesh-node-t114/",
  "vendor": "Heltec"
 }
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit db60f07ac298b6161ca553b3868b542cceadcac4
+Subproject commit b448d4a94fa4b15fbea8421074ac2a943795601f
--- a/src/BluetoothStatus.h
+++ b/src/BluetoothStatus.h
@ -88,10 +88,16 @@ class BluetoothStatus : public Status
                break;
            case ConnectionState::CONNECTED:
                LOG_DEBUG("BluetoothStatus CONNECTED");
+#ifdef BLE_LED
+                digitalWrite(BLE_LED, HIGH);
+#endif
                break;

            case ConnectionState::DISCONNECTED:
                LOG_DEBUG("BluetoothStatus DISCONNECTED");
+#ifdef BLE_LED
+                digitalWrite(BLE_LED, LOW);
+#endif
                break;
            }
        }
@ -102,4 +108,4 @@ class BluetoothStatus : public Status

 } // namespace meshtastic

-extern meshtastic::BluetoothStatus *bluetoothStatus;
+extern meshtastic::BluetoothStatus *bluetoothStatus;
--- a/src/main.cpp
+++ b/src/main.cpp
@ -299,6 +299,16 @@ void setup()
    digitalWrite(USER_LED, HIGH ^ LED_STATE_ON);
 #endif

+#ifdef WIFI_LED
+    pinMode(WIFI_LED, OUTPUT);
+    digitalWrite(WIFI_LED, LOW);
+#endif
+
+#ifdef BLE_LED
+    pinMode(BLE_LED, OUTPUT);
+    digitalWrite(BLE_LED, LOW);
+#endif
+
 #if defined(T_DECK)
    // GPIO10 manages all peripheral power supplies
    // Turn on peripheral power immediately after MUC starts.
--- a/src/mesh/NodeDB.cpp
+++ b/src/mesh/NodeDB.cpp
@ -8,6 +8,7 @@
 #include "Default.h"
 #include "FSCommon.h"
 #include "MeshRadio.h"
+#include "MeshService.h"
 #include "NodeDB.h"
 #include "PacketHistory.h"
 #include "PowerFSM.h"
@ -277,6 +278,7 @@ NodeDB::NodeDB()
            config.security.private_key.size = 32;
            owner.public_key.size = 32;
            memcpy(owner.public_key.bytes, config.security.public_key.bytes, 32);
+            keyIsLowEntropy = checkLowEntropyPublicKey(owner.public_key);
        }
    }
 #elif !(MESHTASTIC_EXCLUDE_PKI)
@ -285,8 +287,12 @@ NodeDB::NodeDB()
        owner.public_key.size = config.security.public_key.size;
        memcpy(owner.public_key.bytes, config.security.public_key.bytes, config.security.public_key.size);
        crypto->setDHPrivateKey(config.security.private_key.bytes);
+        keyIsLowEntropy = checkLowEntropyPublicKey(owner.public_key);
    }
 #endif
+    if (keyIsLowEntropy) {
+        LOG_WARN(LOW_ENTROPY_WARNING);
+    }
    // Include our owner in the node db under our nodenum
    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(getNodeNum());
    info->user = TypeConversions::ConvertToUserLite(owner);
@ -1559,8 +1565,20 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
    }

 #if !(MESHTASTIC_EXCLUDE_PKI)
-    if (p.public_key.size > 0) {
+    if (p.public_key.size == 32) {
        printBytes("Incoming Pubkey: ", p.public_key.bytes, 32);
+
+        // Alert the user if a remote node is advertising public key that matches our own
+        if (owner.public_key.size == 32 && memcmp(p.public_key.bytes, owner.public_key.bytes, 32) == 0) {
+            char warning[] = "Remote device %s has advertised your public key. This may indicate a low-entropy key. You may need "
+                             "to regenerate your public keys.";
+            LOG_WARN(warning, p.long_name);
+            meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
+            cn->level = meshtastic_LogRecord_Level_WARNING;
+            cn->time = getValidTime(RTCQualityFromNet);
+            sprintf(cn->message, warning, p.long_name);
+            service->sendClientNotification(cn);
+        }
    }
    if (info->user.public_key.size > 0) { // if we have a key for this user already, don't overwrite with a new one
        LOG_INFO("Public Key set for node, not updating!");
@ -1734,6 +1752,30 @@ UserLicenseStatus NodeDB::getLicenseStatus(uint32_t nodeNum)
    return info->user.is_licensed ? UserLicenseStatus::Licensed : UserLicenseStatus::NotLicensed;
 }

+bool NodeDB::checkLowEntropyPublicKey(const meshtastic_User_public_key_t keyToTest)
+{
+    uint8_t keyHash[32] = {0};
+    memcpy(keyHash, keyToTest.bytes, keyToTest.size);
+    crypto->hash(keyHash, 32);
+    if (memcmp(keyHash, LOW_ENTROPY_HASH1, sizeof(LOW_ENTROPY_HASH1)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH2, sizeof(LOW_ENTROPY_HASH2)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH3, sizeof(LOW_ENTROPY_HASH3)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH4, sizeof(LOW_ENTROPY_HASH4)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH5, sizeof(LOW_ENTROPY_HASH5)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH6, sizeof(LOW_ENTROPY_HASH6)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH7, sizeof(LOW_ENTROPY_HASH7)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH8, sizeof(LOW_ENTROPY_HASH8)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH9, sizeof(LOW_ENTROPY_HASH9)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH10, sizeof(LOW_ENTROPY_HASH10)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH11, sizeof(LOW_ENTROPY_HASH11)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH12, sizeof(LOW_ENTROPY_HASH12)) == 0 ||
+        memcmp(keyHash, LOW_ENTROPY_HASH13, sizeof(LOW_ENTROPY_HASH13)) == 0) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
 bool NodeDB::backupPreferences(meshtastic_AdminMessage_BackupLocation location)
 {
    bool success = false;
--- a/src/mesh/NodeDB.h
+++ b/src/mesh/NodeDB.h
@ -17,6 +17,49 @@
 #include "PortduinoGlue.h"
 #endif

+#if !defined(MESHTASTIC_EXCLUDE_PKI)
+
+static const uint8_t LOW_ENTROPY_HASH1[] = {0xf4, 0x7e, 0xcc, 0x17, 0xe6, 0xb4, 0xa3, 0x22, 0xec, 0xee, 0xd9,
+                                            0x08, 0x4f, 0x39, 0x63, 0xea, 0x80, 0x75, 0xe1, 0x24, 0xce, 0x05,
+                                            0x36, 0x69, 0x63, 0xb2, 0xcb, 0xc0, 0x28, 0xd3, 0x34, 0x8b};
+static const uint8_t LOW_ENTROPY_HASH2[] = {0x5a, 0x9e, 0xa2, 0xa6, 0x8a, 0xa6, 0x66, 0xc1, 0x5f, 0x55, 0x00,
+                                            0x64, 0xa3, 0xa6, 0xfe, 0x71, 0xc0, 0xbb, 0x82, 0xc3, 0x32, 0x3d,
+                                            0x7a, 0x7a, 0xe3, 0x6e, 0xfd, 0xdd, 0xad, 0x3a, 0x66, 0xb9};
+static const uint8_t LOW_ENTROPY_HASH3[] = {0xb3, 0xdf, 0x3b, 0x2e, 0x67, 0xb6, 0xd5, 0xf8, 0xdf, 0x76, 0x2c,
+                                            0x45, 0x5e, 0x2e, 0xbd, 0x16, 0xc5, 0xf8, 0x67, 0xaa, 0x15, 0xf8,
+                                            0x92, 0x0b, 0xdf, 0x5a, 0x66, 0x50, 0xac, 0x0d, 0xbb, 0x2f};
+static const uint8_t LOW_ENTROPY_HASH4[] = {0x3b, 0x8f, 0x86, 0x3a, 0x38, 0x1f, 0x77, 0x39, 0xa9, 0x4e, 0xef,
+                                            0x91, 0x18, 0x5a, 0x62, 0xe1, 0xaa, 0x9d, 0x36, 0xea, 0xce, 0x60,
+                                            0x35, 0x8d, 0x9d, 0x1f, 0xf4, 0xb8, 0xc9, 0x13, 0x6a, 0x5d};
+static const uint8_t LOW_ENTROPY_HASH5[] = {0x36, 0x7e, 0x2d, 0xe1, 0x84, 0x5f, 0x42, 0x52, 0x29, 0x11, 0x0a,
+                                            0x25, 0x64, 0x54, 0x6a, 0x6b, 0xfd, 0xb6, 0x65, 0xff, 0x15, 0x1a,
+                                            0x51, 0x71, 0x22, 0x40, 0x57, 0xf6, 0x91, 0x9b, 0x64, 0x58};
+static const uint8_t LOW_ENTROPY_HASH6[] = {0x16, 0x77, 0xeb, 0xa4, 0x52, 0x91, 0xfb, 0x26, 0xcf, 0x8f, 0xd7,
+                                            0xd9, 0xd1, 0x5d, 0xc4, 0x68, 0x73, 0x75, 0xed, 0xc5, 0x95, 0x58,
+                                            0xee, 0x90, 0x56, 0xd4, 0x2f, 0x31, 0x29, 0xf7, 0x8c, 0x1f};
+static const uint8_t LOW_ENTROPY_HASH7[] = {0x31, 0x8c, 0xa9, 0x5e, 0xed, 0x3c, 0x12, 0xbf, 0x97, 0x9c, 0x47,
+                                            0x8e, 0x98, 0x9d, 0xc2, 0x3e, 0x86, 0x23, 0x90, 0x29, 0xc8, 0xb0,
+                                            0x20, 0xf8, 0xb1, 0xb0, 0xaa, 0x19, 0x2a, 0xcf, 0x0a, 0x54};
+static const uint8_t LOW_ENTROPY_HASH8[] = {0xa4, 0x8a, 0x99, 0x0e, 0x51, 0xdc, 0x12, 0x20, 0xf3, 0x13, 0xf5,
+                                            0x2b, 0x3a, 0xe2, 0x43, 0x42, 0xc6, 0x52, 0x98, 0xcd, 0xbb, 0xca,
+                                            0xb1, 0x31, 0xa0, 0xd4, 0xd6, 0x30, 0xf3, 0x27, 0xfb, 0x49};
+static const uint8_t LOW_ENTROPY_HASH9[] = {0xd2, 0x3f, 0x13, 0x8d, 0x22, 0x04, 0x8d, 0x07, 0x59, 0x58, 0xa0,
+                                            0xf9, 0x55, 0xcf, 0x30, 0xa0, 0x2e, 0x2f, 0xca, 0x80, 0x20, 0xe4,
+                                            0xde, 0xa1, 0xad, 0xd9, 0x58, 0xb3, 0x43, 0x2b, 0x22, 0x70};
+static const uint8_t LOW_ENTROPY_HASH10[] = {0x40, 0x41, 0xec, 0x6a, 0xd2, 0xd6, 0x03, 0xe4, 0x9a, 0x9e, 0xbd,
+                                             0x6c, 0x0a, 0x9b, 0x75, 0xa4, 0xbc, 0xab, 0x6f, 0xa7, 0x95, 0xff,
+                                             0x2d, 0xf6, 0xe9, 0xb9, 0xab, 0x4c, 0x0c, 0x1c, 0xd0, 0x3b};
+static const uint8_t LOW_ENTROPY_HASH11[] = {0x22, 0x49, 0x32, 0x2b, 0x00, 0xf9, 0x22, 0xfa, 0x17, 0x02, 0xe9,
+                                             0x64, 0x82, 0xf0, 0x4d, 0x1b, 0xc7, 0x04, 0xfc, 0xdc, 0x8c, 0x5e,
+                                             0xb6, 0xd9, 0x16, 0xd6, 0x37, 0xce, 0x59, 0xaa, 0x09, 0x49};
+static const uint8_t LOW_ENTROPY_HASH12[] = {0x48, 0x6f, 0x1e, 0x48, 0x97, 0x88, 0x64, 0xac, 0xe8, 0xeb, 0x30,
+                                             0xa3, 0xc3, 0xe1, 0xcf, 0x97, 0x39, 0xa6, 0x55, 0x5b, 0x5f, 0xbf,
+                                             0x18, 0xb7, 0x3a, 0xdf, 0xa8, 0x75, 0xe7, 0x9d, 0xe0, 0x1e};
+static const uint8_t LOW_ENTROPY_HASH13[] = {0x09, 0xb4, 0xe2, 0x6d, 0x28, 0x98, 0xc9, 0x47, 0x66, 0x46, 0xbf,
+                                             0xff, 0x58, 0x17, 0x91, 0xaa, 0xc3, 0xbf, 0x4a, 0x9d, 0x0b, 0x88,
+                                             0xb1, 0xf1, 0x03, 0xdd, 0x61, 0xd7, 0xba, 0x9e, 0x64, 0x98};
+static const char LOW_ENTROPY_WARNING[] = "Your Device is configured with a low entropy key. Suggest regenerating DM keys";
+#endif
 /*
 DeviceState versions used to be defined in the .proto file but really only this function cares.  So changed to a
 #define here.
@ -87,6 +130,9 @@ class NodeDB
    Observable<const meshtastic::NodeStatus *> newStatus;
    pb_size_t numMeshNodes;

+    bool keyIsLowEntropy = false;
+    bool hasWarned = false;
+
    /// don't do mesh based algorithm for node id assignment (initially)
    /// instead just store in flash - possibly even in the initial alpha release do this hack
    NodeDB();
@ -205,6 +251,8 @@ class NodeDB

    bool hasValidPosition(const meshtastic_NodeInfoLite *n);

+    bool checkLowEntropyPublicKey(const meshtastic_User_public_key_t keyToTest);
+
    bool backupPreferences(meshtastic_AdminMessage_BackupLocation location);
    bool restorePreferences(meshtastic_AdminMessage_BackupLocation location,
                            int restoreWhat = SEGMENT_CONFIG | SEGMENT_MODULECONFIG | SEGMENT_DEVICESTATE | SEGMENT_CHANNELS);
--- a/src/mesh/Router.cpp
+++ b/src/mesh/Router.cpp
@ -548,6 +548,19 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
            numbytes += MESHTASTIC_PKC_OVERHEAD;
            p->channel = 0;
            p->pki_encrypted = true;
+
+            // warn the user about a low entropy key
+            if (nodeDB->keyIsLowEntropy) {
+                LOG_WARN(LOW_ENTROPY_WARNING);
+                if (!nodeDB->hasWarned) {
+                    meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
+                    cn->level = meshtastic_LogRecord_Level_WARNING;
+                    cn->time = getValidTime(RTCQualityFromNet);
+                    sprintf(cn->message, LOW_ENTROPY_WARNING);
+                    service->sendClientNotification(cn);
+                    nodeDB->hasWarned = true;
+                }
+            }
        } else {
            if (p->pki_encrypted == true) {
                // Client specifically requested PKI encryption
--- a/src/mesh/generated/meshtastic/mesh.pb.h
+++ b/src/mesh/generated/meshtastic/mesh.pb.h
@ -264,6 +264,9 @@ typedef enum _meshtastic_HardwareModel {
    /* *
 Lilygo TLora Pager */
    meshtastic_HardwareModel_T_LORA_PAGER = 103,
+    /* *
+ GAT562 Mesh Trial Tracker */
+    meshtastic_HardwareModel_GAT562_MESH_TRIAL_TRACKER = 104,
    /* ------------------------------------------------------------------------------------------------------------------------------------------
 Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
 ------------------------------------------------------------------------------------------------------------------------------------------ */
--- a/src/mesh/wifi/WiFiAPClient.cpp
+++ b/src/mesh/wifi/WiFiAPClient.cpp
@ -331,9 +331,15 @@ static void WiFiEvent(WiFiEvent_t event)
        break;
    case ARDUINO_EVENT_WIFI_STA_CONNECTED:
        LOG_INFO("Connected to access point");
+#ifdef WIFI_LED
+        digitalWrite(WIFI_LED, HIGH);
+#endif
        break;
    case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
        LOG_INFO("Disconnected from WiFi access point");
+#ifdef WIFI_LED
+        digitalWrite(WIFI_LED, LOW);
+#endif
        if (!isReconnecting) {
            WiFi.disconnect(false, true);
            syslog.disable();
@ -382,9 +388,15 @@ static void WiFiEvent(WiFiEvent_t event)
        break;
    case ARDUINO_EVENT_WIFI_AP_START:
        LOG_INFO("WiFi access point started");
+#ifdef WIFI_LED
+        digitalWrite(WIFI_LED, HIGH);
+#endif
        break;
    case ARDUINO_EVENT_WIFI_AP_STOP:
        LOG_INFO("WiFi access point stopped");
+#ifdef WIFI_LED
+        digitalWrite(WIFI_LED, LOW);
+#endif
        break;
    case ARDUINO_EVENT_WIFI_AP_STACONNECTED:
        LOG_INFO("Client connected");
@ -478,4 +490,4 @@ uint8_t getWifiDisconnectReason()
 {
    return wifiDisconnectReason;
 }
-#endif
+#endif
--- a/src/nimble/NimbleBluetooth.cpp
+++ b/src/nimble/NimbleBluetooth.cpp
@ -174,6 +174,11 @@ void NimbleBluetooth::deinit()
 {
 #ifdef ARCH_ESP32
    LOG_INFO("Disable bluetooth until reboot");
+
+#ifdef BLE_LED
+    digitalWrite(BLE_LED, LOW);
+#endif
+
    NimBLEDevice::deinit();
 #endif
 }
--- a/src/sleep.cpp
+++ b/src/sleep.cpp
@ -332,7 +332,7 @@ void doDeepSleep(uint32_t msecToWake, bool skipPreflight = false, bool skipSaveN
    }
 #endif

-#if defined(ARCH_ESP32) && defined(I2C_SDA)
+#if !MESHTASTIC_EXCLUDE_I2C && defined(ARCH_ESP32) && defined(I2C_SDA)
    // Added by https://github.com/meshtastic/firmware/pull/4418
    // Possibly to support Heltec Capsule Sensor?
    Wire.end();
@ -542,4 +542,4 @@ void enableLoraInterrupt()
    }
 #endif
 }
-#endif
+#endif
--- a/variants/heltec_wireless_bridge/platformio.ini
+++ b/variants/heltec_wireless_bridge/platformio.ini
@ -3,4 +3,21 @@
 extends = esp32_base
 board = heltec_wifi_lora_32
 build_flags = 
-  ${esp32_base.build_flags} -D HELTEC_WIRELESS_BRIDGE -I variants/heltec_wireless_bridge
+  ${esp32_base.build_flags}
+  -I variants/heltec_wireless_bridge
+  -D HELTEC_WIRELESS_BRIDGE
+  -D BOARD_HAS_PSRAM
+  -D RADIOLIB_EXCLUDE_LR11X0=1
+  -D RADIOLIB_EXCLUDE_SX128X=1
+  -D MESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
+  -D MESHTASTIC_EXCLUDE_DETECTIONSENSOR=1
+  -D MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR=1
+  -D MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR_EXTERNAL=1
+  -D MESHTASTIC_EXCLUDE_EXTERNALNOTIFICATION=1
+  -D MESHTASTIC_EXCLUDE_GPS=1
+  -D MESHTASTIC_EXCLUDE_I2C=1
+  -D MESHTASTIC_EXCLUDE_INPUTBROKER=1
+  -D MESHTASTIC_EXCLUDE_POWER_FSM=1
+  -D MESHTASTIC_EXCLUDE_SERIAL=1
+  -D MESHTASTIC_EXCLUDE_SCREEN=1
+  -D MESHTASTIC_EXCLUDE_WAYPOINT=1
--- a/variants/heltec_wireless_bridge/variant.h
+++ b/variants/heltec_wireless_bridge/variant.h
@ -1,29 +1,41 @@
-// the default ESP32 Pin of 15 is the Oled SCL, set to 36 and 37 and works fine.
-// Tested on Neo6m module.
+
+// updated variant 20250420 berlincount, tested with HTIT-TB
+//
+// connections in HTIT-WB
+// per https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf
+// md5: a0e6ae10ff76611aa61433366b2e4f5c  esp32_datasheet_en.pdf
+// per https://resource.heltec.cn/download/Wireless_Bridge/Schematic_Diagram_HTIT-WB_V0.2.pdf
+// md5: d5c1b0219ece347dd8cee866d7d3ab0a  Schematic_Diagram_HTIT-WB_V0.2.pdf
+
+#define NO_EXT_GPIO 1
+#define NO_GPS 1
+
+#define HAS_GPS 0 // GPS is not equipped
 #undef GPS_RX_PIN
 #undef GPS_TX_PIN
-#define GPS_RX_PIN 36
-#define GPS_TX_PIN 33

-#ifndef USE_JTAG  // gpio15 is TDO for JTAG, so no I2C on this board while doing jtag
-#define I2C_SDA 4 // I2C pins for this board
-#define I2C_SCL 15
-#endif
-
-#define LED_PIN 25   // If defined we will blink this LED
-#define BUTTON_PIN 0 // If defined, this will be used for user button presses
+// Green / Lora = PIN 22 / GPIO2, Yellow / Wifi = PIN 23 / GPIO0, Blue / BLE = PIN 25 / GPIO16
+#define LED_PIN 22
+#define WIFI_LED 23
+#define BLE_LED 25

+// ESP32-D0WDQ6 direct pins SX1276
 #define USE_RF95
-#define LORA_DIO0 26 // a No connect on the SX1262 module
-#ifndef USE_JTAG
-#define LORA_RESET 14
-#endif
+#define LORA_DIO0 26
 #define LORA_DIO1 35
-#define LORA_DIO2 34 // Not really used
+#define LORA_DIO2 34
+#define LORA_SCK 05
+#define LORA_MISO 19
+#define LORA_MOSI 27
+#define LORA_CS 18

-// ratio of voltage divider = 3.20 (R1=100k, R2=220k)
-#define ADC_MULTIPLIER 3.2
+// several things are not possible with JTAG enabled
+#ifndef USE_JTAG
+#define LORA_RESET 14 // LoRa Reset shares a pin with MTMS
+#define I2C_SDA 4     // SD_DATA1 going to W25Q64, but
+#define I2C_SCL 15    // SD_CMD shared a pin with MTD0
+#endif

-#define BATTERY_PIN 13 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC2_GPIO13_CHANNEL
-#define BAT_MEASURE_ADC_UNIT 2
+// user button is present on device, but currently untested & unconfigured - couldn't figure out how it's connected
+
+// battery support is present within device, but currently untested & unconfigured - couldn't find reliable information yet