Slight nav bar ui change in notes mode and improved rename function responsiveness

Shift+Backspace → save (editing), delete (reading/file list).
Shift+Enter → rename from file list.
RTC time passed via setTimestamp() when opening notes."

examples/companion_radio/MyMesh.h

@@ -8,11 +8,11 @@
 #define FIRMWARE_VER_CODE 8
 
 #ifndef FIRMWARE_BUILD_DATE
-#define FIRMWARE_BUILD_DATE "10 Feb 2026"
+#define FIRMWARE_BUILD_DATE "12 Feb 2026"
 #endif
 
 #ifndef FIRMWARE_VERSION
-#define FIRMWARE_VERSION "Meck v0.8.3"
+#define FIRMWARE_VERSION "Meck v0.8.5"
 #endif
 
 #if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
@@ -72,11 +72,6 @@
 
 /* -------------------------------------------------------------------------------------- */
 
-// SD-backed settings persistence (defined in main.cpp for T-Deck Pro)
-#if defined(LilyGo_TDeck_Pro) && defined(HAS_SDCARD)
-  extern void backupSettingsToSD();
-#endif
-
 #define REQ_TYPE_GET_STATUS             0x01 // same as _GET_STATS
 #define REQ_TYPE_KEEP_ALIVE             0x02
 #define REQ_TYPE_GET_TELEMETRY_DATA     0x03
@@ -174,23 +169,12 @@ protected:
   }
 
 public:
-  void savePrefs() {
-    _store->savePrefs(_prefs, sensors.node_lat, sensors.node_lon);
-    #if defined(LilyGo_TDeck_Pro) && defined(HAS_SDCARD)
-      backupSettingsToSD();
-    #endif
-  }
+  void savePrefs() { _store->savePrefs(_prefs, sensors.node_lat, sensors.node_lon); }
   void saveChannels() {
     _store->saveChannels(this);
-    #if defined(LilyGo_TDeck_Pro) && defined(HAS_SDCARD)
-      backupSettingsToSD();
-    #endif
   }
   void saveContacts() {
     _store->saveContacts(this);
-    #if defined(LilyGo_TDeck_Pro) && defined(HAS_SDCARD)
-      backupSettingsToSD();
-    #endif
   }
 
 private:

examples/companion_radio/main.cpp

@@ -3,12 +3,15 @@
 #include "MyMesh.h"
 #include "variant.h"   // Board-specific defines (HAS_GPS, etc.)
 #include "target.h"    // For sensors, board, etc.
+#include "GPSDutyCycle.h"
+#include "CPUPowerManager.h"
 
 // T-Deck Pro Keyboard support
 #if defined(LilyGo_TDeck_Pro)
   #include "TCA8418Keyboard.h"
   #include <SD.h>
   #include "TextReaderScreen.h"
+  #include "NotesScreen.h"
   #include "ContactsScreen.h"
   #include "ChannelScreen.h"
   #include "SettingsScreen.h"
@@ -23,7 +26,7 @@
   static uint8_t composeChannelIdx = 0;
   static unsigned long lastComposeRefresh = 0;
   static bool composeNeedsRefresh = false;
-  #define COMPOSE_REFRESH_INTERVAL 600  // ms between e-ink refreshes while typing (refresh takes ~650ms)
+  #define COMPOSE_REFRESH_INTERVAL 100  // ms before starting e-ink refresh after keypress (refresh itself takes ~644ms)
 
   // DM compose mode (direct message to a specific contact)
   static bool composeDM = false;
@@ -40,6 +43,15 @@
   
   // Text reader mode state
   static bool readerMode = false;
+
+  // Notes mode state
+  static bool notesMode = false;
+
+  // Power management
+  #if HAS_GPS
+    GPSDutyCycle gpsDuty;
+  #endif
+  CPUPowerManager cpuPower;
   
   void initKeyboard();
   void handleKeyboardInput();
@@ -392,7 +404,7 @@ void setup() {
   MESH_DEBUG_PRINTLN("setup() - SPIFFS.begin() done");
 
   // ---------------------------------------------------------------------------
-  // Early SD card init — needed BEFORE the_mesh.begin() so we can restore
+  // Early SD card init — needed BEFORE the_mesh.begin() so we can restore
   // settings from a previous firmware flash.  The display SPI bus is already
   // up (display.begin() ran earlier), so SD can share it now.
   // ---------------------------------------------------------------------------
@@ -448,12 +460,6 @@ void setup() {
   the_mesh.startInterface(serial_interface);
   MESH_DEBUG_PRINTLN("setup() - the_mesh.startInterface() done");
 
-  // T-Deck Pro: default BLE to OFF on boot (user can toggle with Bluetooth page)
-  #if defined(LilyGo_TDeck_Pro)
-    serial_interface.disable();
-    MESH_DEBUG_PRINTLN("setup() - BLE disabled by default (toggle via home screen)");
-  #endif
-
 #else
   #error "need to define filesystem"
 #endif
@@ -501,10 +507,17 @@ void setup() {
     if (reader) {
       reader->setSDReady(true);
       if (disp) {
+        cpuPower.setBoost();  // Boost CPU for EPUB processing
         reader->bootIndex(*disp);
       }
     }
 
+    // Tell notes screen that SD is ready
+    NotesScreen* notesScr = (NotesScreen*)ui_task.getNotesScreen();
+    if (notesScr) {
+      notesScr->setSDReady(true);
+    }
+
     // Do an initial settings backup to SD (captures any first-boot defaults)
     backupSettingsToSD();
   }
@@ -527,13 +540,29 @@ void setup() {
   }
   #endif
 
-  // Enable GPS by default on T-Deck Pro
+  // GPS duty cycle — honour saved pref, default to enabled on first boot
   #if HAS_GPS
-    // Set GPS enabled in both sensor manager and node prefs
-    sensors.setSettingValue("gps", "1");
-    the_mesh.getNodePrefs()->gps_enabled = 1;
-    the_mesh.savePrefs();  // SD backup triggered automatically
-    MESH_DEBUG_PRINTLN("setup() - GPS enabled by default");
+  {
+    bool gps_wanted = the_mesh.getNodePrefs()->gps_enabled;
+    gpsDuty.setStreamCounter(&gpsStream);
+    gpsDuty.begin(gps_wanted);
+    if (gps_wanted) {
+      sensors.setSettingValue("gps", "1");
+    } else {
+      sensors.setSettingValue("gps", "0");
+    }
+    MESH_DEBUG_PRINTLN("setup() - GPS duty cycle started (enabled=%d)", gps_wanted);
+  }
+  #endif
+
+  // CPU frequency scaling — drop to 80 MHz for idle mesh listening
+  cpuPower.begin();
+
+  // T-Deck Pro: BLE starts disabled for standalone-first operation
+  // User can toggle it on from the Bluetooth home page (Enter or long-press)
+  #if defined(LilyGo_TDeck_Pro) && defined(BLE_PIN_CODE)
+    serial_interface.disable();
+    MESH_DEBUG_PRINTLN("setup() - BLE disabled at boot (standalone mode)");
   #endif
 
   MESH_DEBUG_PRINTLN("=== setup() - COMPLETE ===");
@@ -541,26 +570,54 @@ void setup() {
 
 void loop() {
   the_mesh.loop();
+
+  // GPS duty cycle — check for fix and manage power state
+  #if HAS_GPS
+  {
+    bool gps_hw_on = gpsDuty.loop();
+    if (gps_hw_on) {
+      LocationProvider* lp = sensors.getLocationProvider();
+      if (lp != NULL && lp->isValid()) {
+        gpsDuty.notifyFix();
+      }
+    }
+  }
+  #endif
+
   sensors.loop();
+
+  // CPU frequency auto-timeout back to idle
+  cpuPower.loop();
 #ifdef DISPLAY_CLASS
   // Skip UITask rendering when in compose mode to prevent flickering
   #if defined(LilyGo_TDeck_Pro)
-  if (!composeMode) {
+  // Also suppress during notes editing (same debounce pattern as compose)
+  bool notesEditing = notesMode && ((NotesScreen*)ui_task.getNotesScreen())->isEditing();
+  bool notesRenaming = notesMode && ((NotesScreen*)ui_task.getNotesScreen())->isRenaming();
+  bool notesSuppressLoop = notesEditing || notesRenaming;
+  if (!composeMode && !notesSuppressLoop) {
     ui_task.loop();
   } else {
-    // Handle debounced compose/emoji picker screen refresh
+    // Handle debounced screen refresh (compose, emoji picker, or notes editor)
     if (composeNeedsRefresh && (millis() - lastComposeRefresh) >= COMPOSE_REFRESH_INTERVAL) {
-      if (emojiPickerMode) {
-        drawEmojiPicker();
-      } else {
-        drawComposeScreen();
+      if (composeMode) {
+        if (emojiPickerMode) {
+          drawEmojiPicker();
+        } else {
+          drawComposeScreen();
+        }
+      } else if (notesSuppressLoop) {
+        // Notes editor/rename renders through UITask - force a refresh cycle
+        ui_task.forceRefresh();
+        ui_task.loop();
       }
       lastComposeRefresh = millis();
       composeNeedsRefresh = false;
     }
   }
-  // Track reader mode state for key routing
+  // Track reader/notes mode state for key routing
   readerMode = ui_task.isOnTextReader();
+  notesMode = ui_task.isOnNotesScreen();
   #else
   ui_task.loop();
   #endif
@@ -697,7 +754,7 @@ void handleKeyboardInput() {
     }
     
     // A/D keys switch channels (only when buffer is empty, not in DM mode)
-    if ((key == 'a' || key == 'A') && composePos == 0 && !composeDM) {
+    if ((key == 'a') && composePos == 0 && !composeDM) {
       // Previous channel
       if (composeChannelIdx > 0) {
         composeChannelIdx--;
@@ -716,7 +773,7 @@ void handleKeyboardInput() {
       return;
     }
     
-    if ((key == 'd' || key == 'D') && composePos == 0 && !composeDM) {
+    if ((key == 'd') && composePos == 0 && !composeDM) {
       // Next channel
       ChannelDetails ch;
       uint8_t nextIdx = composeChannelIdx + 1;
@@ -756,7 +813,7 @@ void handleKeyboardInput() {
     
     // Q key: if reading, reader handles it (close book -> file list)
     //         if on file list, exit reader entirely
-    if (key == 'q' || key == 'Q') {
+    if (key == 'q') {
       if (reader->isReading()) {
         // Let the reader handle Q (close book, go to file list)
         ui_task.injectKey('q');
@@ -774,12 +831,147 @@ void handleKeyboardInput() {
     return;
   }
 
+  // *** NOTES MODE ***
+  if (notesMode) {
+    NotesScreen* notes = (NotesScreen*)ui_task.getNotesScreen();
+
+    // ---- EDITING MODE ----
+    if (notes->isEditing()) {
+      // Shift+Backspace = save and exit
+      if (key == '\b') {
+        if (keyboard.wasShiftConsumed()) {
+          Serial.println("Notes: Shift+Backspace, saving...");
+          notes->saveAndExit();
+          ui_task.forceRefresh();
+          return;
+        }
+        // Regular backspace - delete before cursor
+        ui_task.injectKey(key);
+        composeNeedsRefresh = true;
+        return;
+      }
+
+      // Cursor navigation via Shift+WASD (produces uppercase)
+      if (key == 'W') { notes->moveCursorUp();    composeNeedsRefresh = true; return; }
+      if (key == 'A') { notes->moveCursorLeft();   composeNeedsRefresh = true; return; }
+      if (key == 'S') { notes->moveCursorDown();   composeNeedsRefresh = true; return; }
+      if (key == 'D') { notes->moveCursorRight();  composeNeedsRefresh = true; return; }
+
+      // Q when buffer is empty or unchanged = exit (nothing to lose)
+      if (key == 'q' && (notes->isEmpty() || !notes->isDirty())) {
+        Serial.println("Notes: Q exit (nothing to save)");
+        notes->discardAndExit();
+        ui_task.forceRefresh();
+        return;
+      }
+
+      // Enter = newline (pass through with debounce)
+      if (key == '\r') {
+        ui_task.injectKey(key);
+        composeNeedsRefresh = true;
+        return;
+      }
+
+      // All other printable chars (lowercase only - uppercase consumed by cursor nav)
+      if (key >= 32 && key < 127) {
+        ui_task.injectKey(key);
+        composeNeedsRefresh = true;
+        return;
+      }
+      return;
+    }
+
+    // ---- RENAMING MODE ----
+    if (notes->isRenaming()) {
+      // All input goes to rename handler (debounced like editing)
+      ui_task.injectKey(key);
+      composeNeedsRefresh = true;
+      if (!notes->isRenaming()) {
+        // Exited rename mode (confirmed or cancelled)
+        ui_task.forceRefresh();
+      }
+      return;
+    }
+
+    // ---- DELETE CONFIRMATION MODE ----
+    if (notes->isConfirmingDelete()) {
+      ui_task.injectKey(key);
+      if (!notes->isConfirmingDelete()) {
+        // Exited confirm mode
+        ui_task.forceRefresh();
+      }
+      return;
+    }
+
+    // ---- FILE LIST MODE ----
+    if (notes->isInFileList()) {
+      if (key == 'q') {
+        notes->exitNotes();
+        Serial.println("Exiting notes");
+        ui_task.gotoHomeScreen();
+        return;
+      }
+
+      // Shift+Backspace on a file = delete with confirmation
+      if (key == '\b' && keyboard.wasShiftConsumed()) {
+        if (notes->startDeleteFromList()) {
+          ui_task.forceRefresh();
+        }
+        return;
+      }
+
+      // R on a file = rename
+      if (key == 'r') {
+        if (notes->startRename()) {
+          composeNeedsRefresh = true;
+          lastComposeRefresh = millis() - COMPOSE_REFRESH_INTERVAL;  // Trigger on next loop iteration
+        }
+        return;
+      }
+
+      // Normal keys pass through
+      ui_task.injectKey(key);
+      // Check if we just entered editing mode (new note via Enter)
+      if (notes->isEditing()) {
+        composeNeedsRefresh = true;
+        lastComposeRefresh = millis();  // Draw after debounce interval, not immediately
+      }
+      return;
+    }
+
+    // ---- READING MODE ----
+    if (notes->isReading()) {
+      if (key == 'q') {
+        ui_task.injectKey('q');
+        return;
+      }
+
+      // Shift+Backspace = delete note
+      if (key == '\b' && keyboard.wasShiftConsumed()) {
+        Serial.println("Notes: Deleting current note");
+        notes->deleteCurrentNote();
+        ui_task.forceRefresh();
+        return;
+      }
+
+      // All other keys (Enter for edit, W/S for page nav)
+      ui_task.injectKey(key);
+      if (notes->isEditing()) {
+        composeNeedsRefresh = true;
+        lastComposeRefresh = millis();  // Draw after debounce interval, not immediately
+      }
+      return;
+    }
+
+    return;
+  }
+
   // *** SETTINGS MODE ***
   if (ui_task.isOnSettingsScreen()) {
     SettingsScreen* settings = (SettingsScreen*)ui_task.getSettingsScreen();
 
     // Q key: exit settings (when not editing)
-    if (!settings->isEditing() && (key == 'q' || key == 'Q')) {
+    if (!settings->isEditing() && (key == 'q')) {
       if (settings->hasRadioChanges()) {
         // Let settings show "apply changes?" confirm dialog
         ui_task.injectKey(key);
@@ -790,7 +982,7 @@ void handleKeyboardInput() {
       return;
     }
 
-    // All other keys → settings screen via injectKey (no forceRefresh)
+    // All other keys → settings screen via injectKey
     ui_task.injectKey(key);
     return;
   }
@@ -798,28 +990,38 @@ void handleKeyboardInput() {
   // Normal mode - not composing
   switch (key) {
     case 'c':
-    case 'C':
       // Open contacts list
       Serial.println("Opening contacts");
       ui_task.gotoContactsScreen();
       break;
-
+    
     case 'm':
-    case 'M':
       // Go to channel message screen
       Serial.println("Opening channel messages");
       ui_task.gotoChannelScreen();
       break;
     
     case 'e':
-    case 'E':
       // Open text reader (ebooks)
       Serial.println("Opening text reader");
       ui_task.gotoTextReader();
       break;
     
+    case 'n':
+      // Open notes
+      Serial.println("Opening notes");
+      {
+        NotesScreen* notesScr2 = (NotesScreen*)ui_task.getNotesScreen();
+        if (notesScr2) {
+          uint32_t ts = rtc_clock.getCurrentTime();
+          int8_t utcOff = the_mesh.getNodePrefs()->utc_offset_hours;
+          notesScr2->setTimestamp(ts, utcOff);
+        }
+      }
+      ui_task.gotoNotesScreen();
+      break;
+    
     case 's':
-    case 'S':
       // Open settings (from home), or navigate down on channel/contacts
       if (ui_task.isOnChannelScreen() || ui_task.isOnContactsScreen()) {
         ui_task.injectKey('s');  // Pass directly for channel/contacts scrolling
@@ -828,9 +1030,8 @@ void handleKeyboardInput() {
         ui_task.gotoSettingsScreen();
       }
       break;
-    
+
     case 'w':
-    case 'W':
       // Navigate up/previous (scroll on channel screen)
       if (ui_task.isOnChannelScreen() || ui_task.isOnContactsScreen()) {
         ui_task.injectKey('w');  // Pass directly for channel/contacts switching
@@ -839,9 +1040,8 @@ void handleKeyboardInput() {
         ui_task.injectKey(0xF2);  // KEY_PREV
       }
       break;
-    
+      
     case 'a':
-    case 'A':
       // Navigate left or switch channel (on channel screen)
       if (ui_task.isOnChannelScreen() || ui_task.isOnContactsScreen()) {
         ui_task.injectKey('a');  // Pass directly for channel/contacts switching
@@ -852,7 +1052,6 @@ void handleKeyboardInput() {
       break;
       
     case 'd':
-    case 'D':
       // Navigate right or switch channel (on channel screen)
       if (ui_task.isOnChannelScreen() || ui_task.isOnContactsScreen()) {
         ui_task.injectKey('d');  // Pass directly for channel/contacts switching
@@ -898,7 +1097,6 @@ void handleKeyboardInput() {
       break;
       
     case 'q':
-    case 'Q':
     case '\b':
       // Go back to home screen
       Serial.println("Nav: Back to home");
@@ -910,6 +1108,11 @@ void handleKeyboardInput() {
       Serial.println("Nav: Space (Next)");
       ui_task.injectKey(0xF1);  // KEY_NEXT
       break;
+
+    case 'u':
+      // UTC offset edit (home screen GPS page handles this)
+      ui_task.injectKey('u');
+      break;
       
     default:
       Serial.printf("Unhandled key in normal mode: '%c' (0x%02X)\n", key, key);
@@ -1058,6 +1261,8 @@ void drawEmojiPicker() {
 
 void sendComposedMessage() {
   if (composePos == 0) return;
+
+  cpuPower.setBoost();  // Boost CPU for crypto + radio TX
   
   // Convert escape bytes back to UTF-8 for mesh transmission and BLE app
   char utf8Buf[512];

examples/companion_radio/ui-new/Epubprocessor.h

@@ -2,8 +2,8 @@
 // =============================================================================
 // EpubProcessor.h - Convert EPUB files to plain text for TextReaderScreen
 //
-// Pipeline: EPUB (ZIP) → container.xml → OPF spine → extract chapters →
-//           strip XHTML tags → concatenated plain text → cached .txt on SD
+// Pipeline: EPUB (ZIP) → container.xml → OPF spine → extract chapters →
+//           strip XHTML tags → concatenated plain text → cached .txt on SD
 //
 // The resulting .txt file is placed in /books/ and picked up automatically
 // by TextReaderScreen's existing pagination, indexing, and bookmarking.
@@ -14,6 +14,7 @@
 #include <SD.h>
 #include <FS.h>
 #include "EpubZipReader.h"
+#include "Utf8CP437.h"
 
 // Maximum chapters in spine (most novels have 20-80)
 #define EPUB_MAX_CHAPTERS 200
@@ -426,7 +427,7 @@ private:
   //
   // Handles:
   //   - Tag removal (everything between < and >)
-  //   - <p>, <br>, <div>, <h1>-<h6> → newlines
+  //   - <p>, <br>, <div>, <h1>-<h6> → newlines
   //   - HTML entity decoding (&amp; &lt; &gt; &quot; &apos; &#NNN; &#xHH;)
   //   - Collapse multiple whitespace/newlines
   //   - Skip <head>, <style>, <script> content entirely
@@ -547,9 +548,9 @@ private:
         }
       }
 
-      // Handle UTF-8 multi-byte sequences (smart quotes, em dashes, etc.)
-      // These appear as raw bytes in XHTML and must be mapped to ASCII
-      // since the e-ink font only supports ASCII characters.
+      // Handle UTF-8 multi-byte sequences (smart quotes, em dashes, accented chars, etc.)
+      // These appear as raw bytes in XHTML. Typographic chars are mapped to ASCII;
+      // accented Latin chars are preserved as UTF-8 for CP437 rendering on e-ink.
       if ((uint8_t)c >= 0xC0) {
         uint32_t codepoint = 0;
         int extraBytes = 0;
@@ -579,7 +580,8 @@ private:
         if (valid && extraBytes > 0) {
           p += extraBytes;  // Skip continuation bytes (loop increments past lead byte)
 
-          // Map Unicode codepoints to ASCII equivalents
+          // Map Unicode codepoints to displayable equivalents
+          // Typographic chars → ASCII, accented chars → preserved as UTF-8
           char mapped = 0;
           switch (codepoint) {
             case 0x2018: case 0x2019: mapped = '\''; break;  // Smart single quotes
@@ -598,6 +600,21 @@ private:
             default:
               if (codepoint >= 0x20 && codepoint < 0x7F) {
                 mapped = (char)codepoint;  // Basic ASCII range
+              } else if (unicodeToCP437(codepoint)) {
+                // Accented character that the e-ink font can render via CP437.
+                // Preserve as UTF-8 in the output; the text reader will decode
+                // and map to CP437 at render time.
+                if (codepoint <= 0x7FF) {
+                  output[outPos++] = 0xC0 | (codepoint >> 6);
+                  output[outPos++] = 0x80 | (codepoint & 0x3F);
+                } else if (codepoint <= 0xFFFF) {
+                  output[outPos++] = 0xE0 | (codepoint >> 12);
+                  output[outPos++] = 0x80 | ((codepoint >> 6) & 0x3F);
+                  output[outPos++] = 0x80 | (codepoint & 0x3F);
+                }
+                lastWasNewline = false;
+                lastWasSpace = false;
+                continue;  // Already wrote to output
               } else {
                 continue;  // Skip unmappable characters
               }
@@ -608,7 +625,7 @@ private:
           continue;  // Skip malformed UTF-8
         }
       } else if ((uint8_t)c >= 0x80) {
-        // Stray continuation byte (0x80-0xBF) — skip
+        // Stray continuation byte (0x80-0xBF) — skip
         continue;
       }
 
@@ -683,6 +700,37 @@ private:
     if (entityLen == 5 && strncmp(entity, "ldquo", 5) == 0) return '"';
     if (entityLen == 5 && strncmp(entity, "rdquo", 5) == 0) return '"';
 
+    // Common accented character entities → CP437 bytes for built-in font
+    if (entityLen == 6 && strncmp(entity, "eacute", 6) == 0) return (char)0x82;  // é
+    if (entityLen == 6 && strncmp(entity, "egrave", 6) == 0) return (char)0x8A;  // è
+    if (entityLen == 5 && strncmp(entity, "ecirc", 5) == 0) return (char)0x88;   // ê
+    if (entityLen == 4 && strncmp(entity, "euml", 4) == 0) return (char)0x89;    // ë
+    if (entityLen == 6 && strncmp(entity, "agrave", 6) == 0) return (char)0x85;  // à
+    if (entityLen == 6 && strncmp(entity, "aacute", 6) == 0) return (char)0xA0;  // á
+    if (entityLen == 5 && strncmp(entity, "acirc", 5) == 0) return (char)0x83;   // â
+    if (entityLen == 4 && strncmp(entity, "auml", 4) == 0) return (char)0x84;    // ä
+    if (entityLen == 6 && strncmp(entity, "ccedil", 6) == 0) return (char)0x87;  // ç
+    if (entityLen == 6 && strncmp(entity, "iacute", 6) == 0) return (char)0xA1;  // í
+    if (entityLen == 5 && strncmp(entity, "icirc", 5) == 0) return (char)0x8C;   // î
+    if (entityLen == 4 && strncmp(entity, "iuml", 4) == 0) return (char)0x8B;    // ï
+    if (entityLen == 6 && strncmp(entity, "igrave", 6) == 0) return (char)0x8D;  // ì
+    if (entityLen == 6 && strncmp(entity, "oacute", 6) == 0) return (char)0xA2;  // ó
+    if (entityLen == 5 && strncmp(entity, "ocirc", 5) == 0) return (char)0x93;   // ô
+    if (entityLen == 4 && strncmp(entity, "ouml", 4) == 0) return (char)0x94;    // ö
+    if (entityLen == 6 && strncmp(entity, "ograve", 6) == 0) return (char)0x95;  // ò
+    if (entityLen == 6 && strncmp(entity, "uacute", 6) == 0) return (char)0xA3;  // ú
+    if (entityLen == 5 && strncmp(entity, "ucirc", 5) == 0) return (char)0x96;   // û
+    if (entityLen == 4 && strncmp(entity, "uuml", 4) == 0) return (char)0x81;    // ü
+    if (entityLen == 6 && strncmp(entity, "ugrave", 6) == 0) return (char)0x97;  // ù
+    if (entityLen == 6 && strncmp(entity, "ntilde", 6) == 0) return (char)0xA4;  // ñ
+    if (entityLen == 6 && strncmp(entity, "Eacute", 6) == 0) return (char)0x90;  // É
+    if (entityLen == 6 && strncmp(entity, "Ccedil", 6) == 0) return (char)0x80;  // Ç
+    if (entityLen == 6 && strncmp(entity, "Ntilde", 6) == 0) return (char)0xA5;  // Ñ
+    if (entityLen == 4 && strncmp(entity, "Auml", 4) == 0) return (char)0x8E;    // Ä
+    if (entityLen == 4 && strncmp(entity, "Ouml", 4) == 0) return (char)0x99;    // Ö
+    if (entityLen == 4 && strncmp(entity, "Uuml", 4) == 0) return (char)0x9A;    // Ü
+    if (entityLen == 5 && strncmp(entity, "szlig", 5) == 0) return (char)0xE1;   // ß
+
     // Numeric entities: &#NNN; or &#xHH;
     if (entityLen >= 2 && entity[0] == '#') {
       int codepoint = 0;
@@ -701,14 +749,13 @@ private:
           if (ch >= '0' && ch <= '9') codepoint = codepoint * 10 + (ch - '0');
         }
       }
-      // Map to ASCII (best effort - e-ink font is ASCII only)
+      // Map to displayable character (best effort)
       if (codepoint >= 32 && codepoint < 127) return (char)codepoint;
       if (codepoint == 160) return ' ';   // non-breaking space
-      if (codepoint == 8211 || codepoint == 8212) return '-';  // en/em dash
-      if (codepoint == 8216 || codepoint == 8217) return '\''; // smart quotes
-      if (codepoint == 8220 || codepoint == 8221) return '"';  // smart quotes
-      if (codepoint == 8230) return '.';   // ellipsis
-      if (codepoint == 8226) return '*';   // bullet
+      // Try CP437 mapping for accented characters.
+      // The byte value will be passed through to the built-in font.
+      uint8_t cp437 = unicodeToCP437(codepoint);
+      if (cp437) return (char)cp437;
       // Unknown codepoint > 127: skip it
       return ' ';
     }

examples/companion_radio/ui-new/Textreaderscreen.h

@@ -4,6 +4,7 @@
 #include <helpers/ui/DisplayDriver.h>
 #include <SD.h>
 #include <vector>
+#include "Utf8CP437.h"
 #include "EpubProcessor.h"
 
 // Forward declarations
@@ -14,7 +15,7 @@ class UITask;
 // ============================================================================
 #define BOOKS_FOLDER      "/books"
 #define INDEX_FOLDER      "/.indexes"
-#define INDEX_VERSION     4
+#define INDEX_VERSION     5  // v5: UTF-8 aware word wrap (accented char support)
 #define PREINDEX_PAGES    100
 #define READER_MAX_FILES  50
 #define READER_BUF_SIZE   4096
@@ -57,6 +58,10 @@ inline WrapResult findLineBreak(const char* buffer, int bufLen, int lineStart, i
     }
 
     if (c >= 32) {
+      // Skip UTF-8 continuation bytes (0x80-0xBF) - the lead byte already
+      // counted as one display character, so don't double-count these.
+      if ((uint8_t)c >= 0x80 && (uint8_t)c < 0xC0) continue;
+
       charCount++;
       if (c == ' ' || c == '\t') {
         if (inWord) {
@@ -603,7 +608,7 @@ private:
         _currentPage = cache->lastReadPage;
       }
 
-      // Already fully indexed — open immediately
+      // Already fully indexed — open immediately
       if (cache->fullyIndexed) {
         _totalPages = _pagePositions.size();
         _mode = READING;
@@ -613,7 +618,7 @@ private:
         return;
       }
 
-      // Partially indexed — finish indexing with splash
+      // Partially indexed — finish indexing with splash
       Serial.printf("TextReader: Finishing index for %s (have %d pages so far)\n",
                     actualFilename.c_str(), (int)_pagePositions.size());
 
@@ -629,7 +634,7 @@ private:
       drawSplash("Indexing...", "Please wait", shortName);
 
       if (_pagePositions.empty()) {
-        // Cache had no pages (e.g. dummy entry) — full index from scratch
+        // Cache had no pages (e.g. dummy entry) — full index from scratch
         _pagePositions.push_back(0);
         indexPagesWordWrap(_file, 0, _pagePositions,
                            _linesPerPage, _charsPerLine, 0);
@@ -639,7 +644,7 @@ private:
                            _linesPerPage, _charsPerLine, 0);
       }
     } else {
-      // No cache — full index from scratch
+      // No cache — full index from scratch
       Serial.printf("TextReader: Full index for %s\n", actualFilename.c_str());
 
       char shortName[28];
@@ -855,12 +860,40 @@ private:
       if (wrap.nextStart <= oldPos && wrap.lineEnd >= _pageBufLen) break;
 
       display.setCursor(0, y);
-      // Print line character by character (only printable)
+      // Print line with UTF-8 decoding: multi-byte sequences are decoded
+      // to Unicode codepoints, then mapped to CP437 for the built-in font.
       char charStr[2] = {0, 0};
-      for (int j = pos; j < wrap.lineEnd && j < _pageBufLen; j++) {
-        if (_pageBuf[j] >= 32) {
-          charStr[0] = _pageBuf[j];
+      int j = pos;
+      while (j < wrap.lineEnd && j < _pageBufLen) {
+        uint8_t b = (uint8_t)_pageBuf[j];
+
+        if (b < 32) {
+          // Control character — skip
+          j++;
+          continue;
+        }
+
+        if (b < 0x80) {
+          // Plain ASCII — print directly
+          charStr[0] = (char)b;
           display.print(charStr);
+          j++;
+        } else if (b >= 0xC0) {
+          // UTF-8 lead byte — decode full sequence and map to CP437
+          int savedJ = j;
+          uint32_t cp = decodeUtf8Char(_pageBuf, wrap.lineEnd, &j);
+          uint8_t glyph = unicodeToCP437(cp);
+          if (glyph) {
+            charStr[0] = (char)glyph;
+            display.print(charStr);
+          }
+          // If unmappable (glyph==0), just skip the character
+        } else {
+          // Standalone byte 0x80-0xBF: not a valid UTF-8 lead byte.
+          // Treat as CP437 pass-through (e.g. from EPUB numeric entity decoding).
+          charStr[0] = (char)b;
+          display.print(charStr);
+          j++;
         }
       }
 
@@ -997,7 +1030,7 @@ public:
 
     // --- Pass 1: Fast cache load (no per-file splash screens) ---
     // Try to load existing .idx files from SD for every file.
-    // This is just SD reads — no indexing, no e-ink refreshes.
+    // This is just SD reads — no indexing, no e-ink refreshes.
     _fileCache.clear();
     _fileCache.resize(_fileList.size());  // Pre-allocate slots to maintain alignment with _fileList
 
@@ -1026,7 +1059,7 @@ public:
         // Skip files that loaded from cache
         if (_fileCache[i].filename.length() > 0) continue;
 
-        // Skip .epub files — they'll be converted on first open via openBook()
+        // Skip .epub files — they'll be converted on first open via openBook()
         if (_fileList[i].endsWith(".epub") || _fileList[i].endsWith(".EPUB")) {
           needsIndexCount--;  // Don't count epubs in progress display
           continue;

examples/companion_radio/ui-new/UITask.cpp

@@ -1,7 +1,9 @@
 #include "UITask.h"
 #include <helpers/TxtDataHelpers.h>
 #include "../MyMesh.h"
+#include "NotesScreen.h"
 #include "target.h"
+#include "GPSDutyCycle.h"
 #ifdef WIFI_SSID
   #include <WiFi.h>
 #endif
@@ -329,21 +331,37 @@ public:
       display.drawTextCentered(display.width() / 2, 64 - 11, "advert: " PRESS_LABEL);
 #if ENV_INCLUDE_GPS == 1
     } else if (_page == HomePage::GPS) {
+      extern GPSDutyCycle gpsDuty;
+      extern GPSStreamCounter gpsStream;
       LocationProvider* nmea = sensors.getLocationProvider();
       char buf[50];
       int y = 18;
-      bool gps_state = _task->getGPSState();
-#ifdef PIN_GPS_SWITCH
-      bool hw_gps_state = digitalRead(PIN_GPS_SWITCH);
-      if (gps_state != hw_gps_state) {
-        strcpy(buf, gps_state ? "gps off(hw)" : "gps off(sw)");
+
+      // GPS state line with duty cycle info
+      if (!_node_prefs->gps_enabled) {
+        strcpy(buf, "gps off");
       } else {
-        strcpy(buf, gps_state ? "gps on" : "gps off");
+        switch (gpsDuty.getState()) {
+          case GPSDutyState::ACQUIRING: {
+            uint32_t elapsed = gpsDuty.acquireElapsedSecs();
+            sprintf(buf, "acquiring %us", (unsigned)elapsed);
+            break;
+          }
+          case GPSDutyState::SLEEPING: {
+            uint32_t remain = gpsDuty.sleepRemainingSecs();
+            if (remain >= 60) {
+              sprintf(buf, "sleep %um%02us", (unsigned)(remain / 60), (unsigned)(remain % 60));
+            } else {
+              sprintf(buf, "sleep %us", (unsigned)remain);
+            }
+            break;
+          }
+          default:
+            strcpy(buf, "gps off");
+        }
       }
-#else
-      strcpy(buf, gps_state ? "gps on" : "gps off");
-#endif
       display.drawTextLeftAlign(0, y, buf);
+
       if (nmea == NULL) {
         y = y + 12;
         display.drawTextLeftAlign(0, y, "Can't access GPS");
@@ -355,6 +373,19 @@ public:
         sprintf(buf, "%d", nmea->satellitesCount());
         display.drawTextRightAlign(display.width()-1, y, buf);
         y = y + 12;
+
+        // NMEA sentence counter — confirms baud rate and data flow
+        display.drawTextLeftAlign(0, y, "sentences");
+        if (gpsDuty.isHardwareOn()) {
+          uint16_t sps = gpsStream.getSentencesPerSec();
+          uint32_t total = gpsStream.getSentenceCount();
+          sprintf(buf, "%u/s (%lu)", sps, (unsigned long)total);
+        } else {
+          strcpy(buf, "hw off");
+        }
+        display.drawTextRightAlign(display.width()-1, y, buf);
+        y = y + 12;
+
         display.drawTextLeftAlign(0, y, "pos");
         sprintf(buf, "%.4f %.4f", 
           nmea->getLatitude()/1000000., nmea->getLongitude()/1000000.);
@@ -717,6 +748,7 @@ void UITask::begin(DisplayDriver* display, SensorManager* sensors, NodePrefs* no
   channel_screen = new ChannelScreen(this, &rtc_clock);
   contacts_screen = new ContactsScreen(this, &rtc_clock);
   text_reader = new TextReaderScreen(this);
+  notes_screen = new NotesScreen(this);
   settings_screen = new SettingsScreen(this, &rtc_clock, node_prefs);
   setCurrScreen(splash);
 }
@@ -1037,39 +1069,36 @@ char UITask::handleTripleClick(char c) {
 }
 
 bool UITask::getGPSState() {
-  if (_sensors != NULL) {
-    int num = _sensors->getNumSettings();
-    for (int i = 0; i < num; i++) {
-      if (strcmp(_sensors->getSettingName(i), "gps") == 0) {
-        return !strcmp(_sensors->getSettingValue(i), "1");
-      }
-    }
-  } 
-  return false;
+  #if ENV_INCLUDE_GPS == 1
+    return _node_prefs != NULL && _node_prefs->gps_enabled;
+  #else
+    return false;
+  #endif
 }
 
 void UITask::toggleGPS() {
+  #if ENV_INCLUDE_GPS == 1
+    extern GPSDutyCycle gpsDuty;
+
     if (_sensors != NULL) {
-    // toggle GPS on/off
-    int num = _sensors->getNumSettings();
-    for (int i = 0; i < num; i++) {
-      if (strcmp(_sensors->getSettingName(i), "gps") == 0) {
-        if (strcmp(_sensors->getSettingValue(i), "1") == 0) {
-          _sensors->setSettingValue("gps", "0");
-          _node_prefs->gps_enabled = 0;
-          notify(UIEventType::ack);
-        } else {
-          _sensors->setSettingValue("gps", "1");
-          _node_prefs->gps_enabled = 1;
-          notify(UIEventType::ack);
-        }
-        the_mesh.savePrefs();
-        showAlert(_node_prefs->gps_enabled ? "GPS: Enabled" : "GPS: Disabled", 800);
-        _next_refresh = 0;
-        break;
+      if (_node_prefs->gps_enabled) {
+        // Disable GPS — cut hardware power
+        _sensors->setSettingValue("gps", "0");
+        _node_prefs->gps_enabled = 0;
+        gpsDuty.disable();
+        notify(UIEventType::ack);
+      } else {
+        // Enable GPS — start duty cycle
+        _sensors->setSettingValue("gps", "1");
+        _node_prefs->gps_enabled = 1;
+        gpsDuty.enable();
+        notify(UIEventType::ack);
       }
+      the_mesh.savePrefs();
+      showAlert(_node_prefs->gps_enabled ? "GPS: Enabled" : "GPS: Disabled", 800);
+      _next_refresh = 0;
     }
-  }
+  #endif
 }
 
 void UITask::toggleBuzzer() {
@@ -1157,8 +1186,21 @@ void UITask::gotoTextReader() {
   _next_refresh = 100;
 }
 
+void UITask::gotoNotesScreen() {
+  NotesScreen* notes = (NotesScreen*)notes_screen;
+  if (_display != NULL) {
+    notes->enter(*_display);
+  }
+  setCurrScreen(notes_screen);
+  if (_display != NULL && !_display->isOn()) {
+    _display->turnOn();
+  }
+  _auto_off = millis() + AUTO_OFF_MILLIS;
+  _next_refresh = 100;
+}
+
 void UITask::gotoSettingsScreen() {
-  ((SettingsScreen*)settings_screen)->enter();
+  ((SettingsScreen *) settings_screen)->enter();
   setCurrScreen(settings_screen);
   if (_display != NULL && !_display->isOn()) {
     _display->turnOn();
@@ -1168,7 +1210,7 @@ void UITask::gotoSettingsScreen() {
 }
 
 void UITask::gotoOnboarding() {
-  ((SettingsScreen*)settings_screen)->enterOnboarding();
+  ((SettingsScreen *) settings_screen)->enterOnboarding();
   setCurrScreen(settings_screen);
   if (_display != NULL && !_display->isOn()) {
     _display->turnOn();

examples/companion_radio/ui-new/UITask.h

@@ -54,6 +54,7 @@ class UITask : public AbstractUITask {
   UIScreen* channel_screen;  // Channel message history screen
   UIScreen* contacts_screen; // Contacts list screen
   UIScreen* text_reader;     // *** NEW: Text reader screen ***
+  UIScreen* notes_screen;    // Notes editor screen
   UIScreen* settings_screen; // Settings/onboarding screen
   UIScreen* curr;
 
@@ -80,6 +81,7 @@ public:
   void gotoChannelScreen();  // Navigate to channel message screen
   void gotoContactsScreen(); // Navigate to contacts list
   void gotoTextReader();     // *** NEW: Navigate to text reader ***
+  void gotoNotesScreen();    // Navigate to notes editor
   void gotoSettingsScreen(); // Navigate to settings
   void gotoOnboarding();     // Navigate to settings in onboarding mode
   void showAlert(const char* text, int duration_millis) override;
@@ -90,6 +92,7 @@ public:
   bool isOnChannelScreen() const { return curr == channel_screen; }
   bool isOnContactsScreen() const { return curr == contacts_screen; }
   bool isOnTextReader() const { return curr == text_reader; }  // *** NEW ***
+  bool isOnNotesScreen() const { return curr == notes_screen; }
   bool isOnSettingsScreen() const { return curr == settings_screen; }
   uint8_t getChannelScreenViewIdx() const;
 
@@ -110,6 +113,7 @@ public:
   UIScreen* getCurrentScreen() const { return curr; }
   UIScreen* getMsgPreviewScreen() const { return msg_preview; }
   UIScreen* getTextReaderScreen() const { return text_reader; }  // *** NEW ***
+  UIScreen* getNotesScreen() const { return notes_screen; }
   UIScreen* getContactsScreen() const { return contacts_screen; }
   UIScreen* getChannelScreen() const { return channel_screen; }
   UIScreen* getSettingsScreen() const { return settings_screen; }

examples/companion_radio/ui-new/Utf8cp437.h

@@ -0,0 +1,152 @@
+#pragma once
+// =============================================================================
+// Utf8CP437.h - UTF-8 decoding and Unicode-to-CP437 mapping
+//
+// The Adafruit GFX built-in 6x8 font uses the CP437 character set for codes
+// 128-255. This header provides utilities to:
+//   1. Decode UTF-8 multi-byte sequences into Unicode codepoints
+//   2. Map Unicode codepoints to CP437 byte values for display
+//
+// Used by both EpubProcessor (at XHTML→text conversion time) and
+// TextReaderScreen (at render time for plain .txt files).
+// =============================================================================
+
+// Map a Unicode codepoint to its CP437 equivalent byte.
+// Returns the CP437 byte (0x80-0xFF) for supported accented characters,
+// the codepoint itself for ASCII (0x20-0x7E), or 0 if unmappable.
+inline uint8_t unicodeToCP437(uint32_t cp) {
+  // ASCII passthrough
+  if (cp >= 0x20 && cp < 0x7F) return (uint8_t)cp;
+
+  switch (cp) {
+    // Uppercase accented
+    case 0x00C7: return 0x80;  // Ç
+    case 0x00C9: return 0x90;  // É
+    case 0x00C4: return 0x8E;  // Ä
+    case 0x00C5: return 0x8F;  // Å
+    case 0x00C6: return 0x92;  // Æ
+    case 0x00D6: return 0x99;  // Ö
+    case 0x00DC: return 0x9A;  // Ü
+    case 0x00D1: return 0xA5;  // Ñ
+
+    // Lowercase accented
+    case 0x00E9: return 0x82;  // é
+    case 0x00E2: return 0x83;  // â
+    case 0x00E4: return 0x84;  // ä
+    case 0x00E0: return 0x85;  // à
+    case 0x00E5: return 0x86;  // å
+    case 0x00E7: return 0x87;  // ç
+    case 0x00EA: return 0x88;  // ê
+    case 0x00EB: return 0x89;  // ë
+    case 0x00E8: return 0x8A;  // è
+    case 0x00EF: return 0x8B;  // ï
+    case 0x00EE: return 0x8C;  // î
+    case 0x00EC: return 0x8D;  // ì
+    case 0x00E6: return 0x91;  // æ
+    case 0x00F4: return 0x93;  // ô
+    case 0x00F6: return 0x94;  // ö
+    case 0x00F2: return 0x95;  // ò
+    case 0x00FB: return 0x96;  // û
+    case 0x00F9: return 0x97;  // ù
+    case 0x00FF: return 0x98;  // ÿ
+    case 0x00FC: return 0x81;  // ü
+    case 0x00E1: return 0xA0;  // á
+    case 0x00ED: return 0xA1;  // í
+    case 0x00F3: return 0xA2;  // ó
+    case 0x00FA: return 0xA3;  // ú
+    case 0x00F1: return 0xA4;  // ñ
+
+    // Currency / symbols
+    case 0x00A2: return 0x9B;  // ¢
+    case 0x00A3: return 0x9C;  // £
+    case 0x00A5: return 0x9D;  // ¥
+    case 0x00BF: return 0xA8;  // ¿
+    case 0x00A1: return 0xAD;  // ¡
+    case 0x00AB: return 0xAE;  // «
+    case 0x00BB: return 0xAF;  // »
+    case 0x00B0: return 0xF8;  // °
+    case 0x00B1: return 0xF1;  // ±
+    case 0x00B5: return 0xE6;  // µ
+    case 0x00DF: return 0xE1;  // ß
+
+    // Typographic (smart quotes, dashes, etc.)
+    case 0x2018: case 0x2019: return '\'';  // Smart single quotes
+    case 0x201C: case 0x201D: return '"';   // Smart double quotes
+    case 0x2013: case 0x2014: return '-';   // En/em dash
+    case 0x2010: case 0x2011: case 0x2012: case 0x2015: return '-'; // Hyphens/bars
+    case 0x2026: return 0xFD;              // Ellipsis (CP437 has no …, use ²? no, skip)
+    case 0x2022: return 0x07;              // Bullet → CP437 bullet
+    case 0x00A0: return ' ';               // Non-breaking space
+    case 0x2039: case 0x203A: return '\''; // Single guillemets
+    case 0x2032: return '\'';              // Prime
+    case 0x2033: return '"';               // Double prime
+
+    default: return 0;  // Unmappable
+  }
+}
+
+// Decode a single UTF-8 character from a byte buffer.
+// Returns the Unicode codepoint and advances *pos past the full sequence.
+// If the sequence is invalid, returns 0xFFFD (replacement char) and advances by 1.
+//
+// buf:    input buffer
+// bufLen: total buffer length
+// pos:    pointer to current position (updated on return)
+inline uint32_t decodeUtf8Char(const char* buf, int bufLen, int* pos) {
+  int i = *pos;
+  if (i >= bufLen) return 0;
+
+  uint8_t c = (uint8_t)buf[i];
+
+  // ASCII (single byte)
+  if (c < 0x80) {
+    *pos = i + 1;
+    return c;
+  }
+
+  // Continuation byte without lead byte — skip
+  if (c < 0xC0) {
+    *pos = i + 1;
+    return 0xFFFD;
+  }
+
+  uint32_t codepoint;
+  int extraBytes;
+
+  if ((c & 0xE0) == 0xC0) {
+    codepoint = c & 0x1F;
+    extraBytes = 1;
+  } else if ((c & 0xF0) == 0xE0) {
+    codepoint = c & 0x0F;
+    extraBytes = 2;
+  } else if ((c & 0xF8) == 0xF0) {
+    codepoint = c & 0x07;
+    extraBytes = 3;
+  } else {
+    *pos = i + 1;
+    return 0xFFFD;
+  }
+
+  // Verify we have enough bytes and they're valid continuation bytes
+  if (i + extraBytes >= bufLen) {
+    *pos = i + 1;
+    return 0xFFFD;
+  }
+
+  for (int b = 1; b <= extraBytes; b++) {
+    uint8_t cb = (uint8_t)buf[i + b];
+    if ((cb & 0xC0) != 0x80) {
+      *pos = i + 1;
+      return 0xFFFD;
+    }
+    codepoint = (codepoint << 6) | (cb & 0x3F);
+  }
+
+  *pos = i + 1 + extraBytes;
+  return codepoint;
+}
+
+// Check if a byte is a UTF-8 continuation byte (10xxxxxx)
+inline bool isUtf8Continuation(uint8_t c) {
+  return (c & 0xC0) == 0x80;
+}

variants/lilygo_tdeck_pro/CPUPowerManager.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <Arduino.h>
+
+// CPU Frequency Scaling for ESP32-S3
+//
+// Typical current draw (CPU only, rough):
+//   240 MHz  ~70-80 mA
+//   160 MHz  ~50-60 mA
+//    80 MHz  ~30-40 mA
+//
+// SPI peripherals and UART use their own clock dividers from the APB clock,
+// so LoRa, e-ink, and GPS serial all work fine at 80MHz.
+
+#ifdef ESP32
+
+#ifndef CPU_FREQ_IDLE
+#define CPU_FREQ_IDLE   80     // MHz — normal mesh listening
+#endif
+
+#ifndef CPU_FREQ_BOOST
+#define CPU_FREQ_BOOST  240    // MHz — heavy processing
+#endif
+
+#ifndef CPU_BOOST_TIMEOUT_MS
+#define CPU_BOOST_TIMEOUT_MS  10000  // 10 seconds
+#endif
+
+class CPUPowerManager {
+public:
+  CPUPowerManager() : _boosted(false), _boost_started(0) {}
+
+  void begin() {
+    setCpuFrequencyMhz(CPU_FREQ_IDLE);
+    _boosted = false;
+    MESH_DEBUG_PRINTLN("CPU power: idle at %d MHz", CPU_FREQ_IDLE);
+  }
+
+  void loop() {
+    if (_boosted && (millis() - _boost_started >= CPU_BOOST_TIMEOUT_MS)) {
+      setIdle();
+    }
+  }
+
+  void setBoost() {
+    if (!_boosted) {
+      setCpuFrequencyMhz(CPU_FREQ_BOOST);
+      _boosted = true;
+      MESH_DEBUG_PRINTLN("CPU power: boosted to %d MHz", CPU_FREQ_BOOST);
+    }
+    _boost_started = millis();
+  }
+
+  void setIdle() {
+    if (_boosted) {
+      setCpuFrequencyMhz(CPU_FREQ_IDLE);
+      _boosted = false;
+      MESH_DEBUG_PRINTLN("CPU power: idle at %d MHz", CPU_FREQ_IDLE);
+    }
+  }
+
+  bool isBoosted() const { return _boosted; }
+  uint32_t getFrequencyMHz() const { return getCpuFrequencyMhz(); }
+
+private:
+  bool _boosted;
+  unsigned long _boost_started;
+};
+
+#endif // ESP32

variants/lilygo_tdeck_pro/GPSDutyCycle.h

@@ -0,0 +1,185 @@
+#pragma once
+
+#include <Arduino.h>
+#include "variant.h"
+#include "GPSStreamCounter.h"
+
+// GPS Duty Cycle Manager
+// Controls the hardware GPS enable pin (PIN_GPS_EN) to save power.
+// When enabled, cycles between acquiring a fix and sleeping with power cut.
+//
+// States:
+//   OFF        – User has disabled GPS. Hardware power is cut.
+//   ACQUIRING  – GPS module powered on, waiting for a fix or timeout.
+//   SLEEPING   – GPS module powered off, timer counting down to next cycle.
+
+#if HAS_GPS
+
+// How long to leave GPS powered on while acquiring a fix (ms)
+#ifndef GPS_ACQUIRE_TIMEOUT_MS
+#define GPS_ACQUIRE_TIMEOUT_MS    180000   // 3 minutes
+#endif
+
+// How long to sleep between acquisition cycles (ms)
+#ifndef GPS_SLEEP_DURATION_MS
+#define GPS_SLEEP_DURATION_MS     900000   // 15 minutes
+#endif
+
+// If we get a fix quickly, power off immediately but still respect
+// a minimum on-time so the RTC can sync properly
+#ifndef GPS_MIN_ON_TIME_MS
+#define GPS_MIN_ON_TIME_MS        5000     // 5 seconds after fix
+#endif
+
+enum class GPSDutyState : uint8_t {
+  OFF = 0,       // User-disabled, hardware power off
+  ACQUIRING,     // Hardware on, waiting for fix
+  SLEEPING       // Hardware off, timer running
+};
+
+class GPSDutyCycle {
+public:
+  GPSDutyCycle() : _state(GPSDutyState::OFF), _state_entered(0),
+                   _last_fix_time(0), _got_fix(false), _time_synced(false),
+                   _stream(nullptr) {}
+
+  // Attach the stream counter so we can reset it on power cycles
+  void setStreamCounter(GPSStreamCounter* stream) { _stream = stream; }
+
+  // Call once in setup() after board.begin() and GPS serial init.
+  void begin(bool initial_enable) {
+    if (initial_enable) {
+      _powerOn();
+      _setState(GPSDutyState::ACQUIRING);
+    } else {
+      _powerOff();
+      _setState(GPSDutyState::OFF);
+    }
+  }
+
+  // Call every iteration of loop().
+  // Returns true if GPS hardware is currently powered on.
+  bool loop() {
+    switch (_state) {
+      case GPSDutyState::OFF:
+        return false;
+
+      case GPSDutyState::ACQUIRING: {
+        unsigned long elapsed = millis() - _state_entered;
+
+        if (_got_fix && elapsed >= GPS_MIN_ON_TIME_MS) {
+          MESH_DEBUG_PRINTLN("GPS duty: fix acquired, powering off for %u min",
+                             (unsigned)(GPS_SLEEP_DURATION_MS / 60000));
+          _powerOff();
+          _setState(GPSDutyState::SLEEPING);
+          return false;
+        }
+
+        if (elapsed >= GPS_ACQUIRE_TIMEOUT_MS) {
+          MESH_DEBUG_PRINTLN("GPS duty: acquire timeout (%us), sleeping",
+                             (unsigned)(GPS_ACQUIRE_TIMEOUT_MS / 1000));
+          _powerOff();
+          _setState(GPSDutyState::SLEEPING);
+          return false;
+        }
+
+        return true;
+      }
+
+      case GPSDutyState::SLEEPING: {
+        if (millis() - _state_entered >= GPS_SLEEP_DURATION_MS) {
+          MESH_DEBUG_PRINTLN("GPS duty: waking up for next acquisition cycle");
+          _got_fix = false;
+          _powerOn();
+          _setState(GPSDutyState::ACQUIRING);
+          return true;
+        }
+        return false;
+      }
+    }
+    return false;
+  }
+
+  void notifyFix() {
+    if (_state == GPSDutyState::ACQUIRING && !_got_fix) {
+      _got_fix = true;
+      _last_fix_time = millis();
+      MESH_DEBUG_PRINTLN("GPS duty: fix notification received");
+    }
+  }
+
+  void notifyTimeSync() {
+    _time_synced = true;
+  }
+
+  void enable() {
+    if (_state == GPSDutyState::OFF) {
+      _got_fix = false;
+      _powerOn();
+      _setState(GPSDutyState::ACQUIRING);
+      MESH_DEBUG_PRINTLN("GPS duty: enabled, starting acquisition");
+    }
+  }
+
+  void disable() {
+    _powerOff();
+    _setState(GPSDutyState::OFF);
+    _got_fix = false;
+    MESH_DEBUG_PRINTLN("GPS duty: disabled, power off");
+  }
+
+  void forceWake() {
+    if (_state == GPSDutyState::SLEEPING) {
+      _got_fix = false;
+      _powerOn();
+      _setState(GPSDutyState::ACQUIRING);
+      MESH_DEBUG_PRINTLN("GPS duty: forced wake for user request");
+    }
+  }
+
+  GPSDutyState getState() const { return _state; }
+  bool isHardwareOn() const { return _state == GPSDutyState::ACQUIRING; }
+  bool hadFix() const { return _got_fix; }
+  bool hasTimeSynced() const { return _time_synced; }
+
+  uint32_t sleepRemainingSecs() const {
+    if (_state != GPSDutyState::SLEEPING) return 0;
+    unsigned long elapsed = millis() - _state_entered;
+    if (elapsed >= GPS_SLEEP_DURATION_MS) return 0;
+    return (GPS_SLEEP_DURATION_MS - elapsed) / 1000;
+  }
+
+  uint32_t acquireElapsedSecs() const {
+    if (_state != GPSDutyState::ACQUIRING) return 0;
+    return (millis() - _state_entered) / 1000;
+  }
+
+private:
+  void _powerOn() {
+    #ifdef PIN_GPS_EN
+      digitalWrite(PIN_GPS_EN, GPS_EN_ACTIVE);
+      delay(10);
+    #endif
+    if (_stream) _stream->resetCounters();
+  }
+
+  void _powerOff() {
+    #ifdef PIN_GPS_EN
+      digitalWrite(PIN_GPS_EN, !GPS_EN_ACTIVE);
+    #endif
+  }
+
+  void _setState(GPSDutyState s) {
+    _state = s;
+    _state_entered = millis();
+  }
+
+  GPSDutyState _state;
+  unsigned long _state_entered;
+  unsigned long _last_fix_time;
+  bool _got_fix;
+  bool _time_synced;
+  GPSStreamCounter* _stream;
+};
+
+#endif // HAS_GPS

variants/lilygo_tdeck_pro/GPSStreamCounter.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <Arduino.h>
+
+// Transparent Stream wrapper that counts NMEA sentences (newline-delimited)
+// flowing from the GPS serial port to the MicroNMEA parser.
+//
+// Usage:  Instead of  MicroNMEALocationProvider gps(Serial2, &rtc_clock);
+//         Use:        GPSStreamCounter gpsStream(Serial2);
+//                     MicroNMEALocationProvider gps(gpsStream, &rtc_clock);
+//
+// Every read() call passes through to the underlying stream; when a '\n'
+// is seen the sentence counter increments.  This lets the UI display a
+// live "nmea" count so users can confirm the baud rate is correct and
+// the GPS module is actually sending data.
+
+class GPSStreamCounter : public Stream {
+public:
+  GPSStreamCounter(Stream& inner)
+    : _inner(inner), _sentences(0), _sentences_snapshot(0),
+      _last_snapshot(0), _sentences_per_sec(0) {}
+
+  // --- Stream read interface (passes through) ---
+  int available() override { return _inner.available(); }
+  int peek()      override { return _inner.peek(); }
+
+  int read() override {
+    int c = _inner.read();
+    if (c == '\n') {
+      _sentences++;
+    }
+    return c;
+  }
+
+  // --- Stream write interface (pass through for NMEA commands if needed) ---
+  size_t write(uint8_t b) override { return _inner.write(b); }
+
+  // --- Sentence counting API ---
+
+  // Total sentences received since boot (or last reset)
+  uint32_t getSentenceCount() const { return _sentences; }
+
+  // Sentences received per second (updated each time you call it,
+  // with a 1-second rolling window)
+  uint16_t getSentencesPerSec() {
+    unsigned long now = millis();
+    unsigned long elapsed = now - _last_snapshot;
+    if (elapsed >= 1000) {
+      uint32_t delta = _sentences - _sentences_snapshot;
+      // Scale to per-second if interval wasn't exactly 1000ms
+      _sentences_per_sec = (uint16_t)((delta * 1000UL) / elapsed);
+      _sentences_snapshot = _sentences;
+      _last_snapshot = now;
+    }
+    return _sentences_per_sec;
+  }
+
+  // Reset all counters (e.g. when GPS hardware power cycles)
+  void resetCounters() {
+    _sentences = 0;
+    _sentences_snapshot = 0;
+    _sentences_per_sec = 0;
+    _last_snapshot = millis();
+  }
+
+private:
+  Stream& _inner;
+  volatile uint32_t _sentences;
+  uint32_t _sentences_snapshot;
+  unsigned long _last_snapshot;
+  uint16_t _sentences_per_sec;
+};

variants/lilygo_tdeck_pro/Tca8418keyboard.h

@@ -28,7 +28,10 @@ private:
   uint8_t _addr;
   TwoWire* _wire;
   bool _initialized;
-  bool _shiftActive;   // Sticky shift (one-shot)
+  bool _shiftActive;   // Sticky shift (one-shot or held)
+  bool _shiftConsumed; // Was shift active for the last returned key
+  bool _shiftHeld;     // Shift key physically held down
+  bool _shiftUsedWhileHeld; // Was shift consumed by any key while held
   bool _altActive;     // Sticky alt (one-shot)
   bool _symActive;     // Sticky sym (one-shot)
   unsigned long _lastShiftTime;  // For Shift+key combos
@@ -148,7 +151,7 @@ private:
 public:
   TCA8418Keyboard(uint8_t addr = 0x34, TwoWire* wire = &Wire) 
     : _addr(addr), _wire(wire), _initialized(false), 
-      _shiftActive(false), _altActive(false), _symActive(false), _lastShiftTime(0) {}
+      _shiftActive(false), _shiftConsumed(false), _shiftHeld(false), _shiftUsedWhileHeld(false), _altActive(false), _symActive(false), _lastShiftTime(0) {}
 
   bool begin() {
     // Check if device responds
@@ -203,6 +206,19 @@ public:
     Serial.printf("KB raw: event=0x%02X code=%d pressed=%d count=%d\n", 
                   keyEvent, keyCode, pressed, keyCount);
 
+    // Track shift release (before the general release-ignore)
+    if (!pressed && (keyCode == 35 || keyCode == 31)) {
+      _shiftHeld = false;
+      // If shift was used while held (e.g. cursor nav), clear it completely
+      // so the next bare keypress isn't treated as shifted.
+      // If shift was NOT used (tap-then-release), keep _shiftActive for one-shot.
+      if (_shiftUsedWhileHeld) {
+        _shiftActive = false;
+      }
+      _shiftUsedWhileHeld = false;
+      return 0;
+    }
+
     // Only act on key press, not release
     if (!pressed || keyCode == 0) {
       return 0;
@@ -211,6 +227,8 @@ public:
     // Handle modifier keys - set sticky state and return 0
     if (keyCode == 35 || keyCode == 31) {  // Shift keys
       _shiftActive = true;
+      _shiftHeld = true;
+      _shiftUsedWhileHeld = false;
       _lastShiftTime = millis();
       Serial.println("KB: Shift activated");
       return 0;
@@ -276,7 +294,17 @@ public:
       if (c >= 'a' && c <= 'z') {
         c = c - 'a' + 'A';
       }
-      _shiftActive = false;  // Reset sticky shift
+      // Track that shift was used while physically held
+      if (_shiftHeld) {
+        _shiftUsedWhileHeld = true;
+      }
+      // Only clear shift if it's one-shot (tap), not held down
+      if (!_shiftHeld) {
+        _shiftActive = false;
+      }
+      _shiftConsumed = true; // Record that shift was active for this key
+    } else {
+      _shiftConsumed = false;
     }
     
     if (c != 0) {
@@ -294,4 +322,10 @@ public:
   bool wasShiftRecentlyPressed(unsigned long withinMs = 500) const {
     return (millis() - _lastShiftTime) < withinMs;
   }
+  
+  // Check if shift was active when the most recent key was produced
+  // (immune to e-ink refresh timing unlike wasShiftRecentlyPressed)
+  bool wasShiftConsumed() const {
+    return _shiftConsumed;
+  }
 };

variants/lilygo_tdeck_pro/target.cpp

@@ -17,7 +17,10 @@ ESP32RTCClock fallback_clock;
 AutoDiscoverRTCClock rtc_clock(fallback_clock);
 
 #if HAS_GPS
-  MicroNMEALocationProvider gps(Serial2, &rtc_clock);
+  // Wrap Serial2 with a sentence counter so the UI can show NMEA throughput.
+  // MicroNMEALocationProvider reads through this wrapper transparently.
+  GPSStreamCounter gpsStream(Serial2);
+  MicroNMEALocationProvider gps(gpsStream, &rtc_clock);
   EnvironmentSensorManager sensors(gps);
 #else
   SensorManager sensors;

variants/lilygo_tdeck_pro/target.h

@@ -18,6 +18,7 @@
 #if HAS_GPS
   #include "helpers/sensors/EnvironmentSensorManager.h"
   #include "helpers/sensors/MicroNMEALocationProvider.h"
+  #include "GPSStreamCounter.h"
 #else
   #include <helpers/SensorManager.h>
 #endif
@@ -27,6 +28,7 @@ extern WRAPPER_CLASS radio_driver;
 extern AutoDiscoverRTCClock rtc_clock;
 
 #if HAS_GPS
+  extern GPSStreamCounter gpsStream;
   extern EnvironmentSensorManager sensors;
 #else
   extern SensorManager sensors;