onlyn00bs-badge

display_oled.cpp (39743B)

---

 // Monochrome OLED implementation of the display interface — SSD1309 2.42"
 // (128×64) over I2C, via U8g2. This is the chosen badge display: self-lit
 // (readable in a dark venue), dirt-simple, and a single 18650 runs it for days.
 //
 // 128×64 is tight, so layouts are deliberately terse: a header line + a handful
 // of rows. Handles are truncated to fit. Pixels are the only power cost, so we
 // keep the screen mostly dark.
 
 #if defined(BADGE_DISPLAY_OLED)
 
 #include <Arduino.h>
 #include <U8g2lib.h>
 #include <math.h>
 #include "display.h"
 #include "config.h"
 #include "logos.h"       // GENERATED — boot-card bitmaps
 
 // Hardware-I2C SSD1309. Last two args are SCL/SDA for ESP32 (see config.h).
 static U8G2_SSD1309_128X64_NONAME0_F_HW_I2C
     u8g2(U8G2_R0, U8X8_PIN_NONE, OLED_SCL_PIN, OLED_SDA_PIN);
 
 #define ROW_FONT  u8g2_font_6x10_tf      // ~6px wide → ~21 chars, ~6 rows tall
 #define ROW_CHARS 21
 
 static void truncate(char* dst, const char* src, int maxch) {
   int i = 0;
   for (; src[i] && i < maxch; i++) dst[i] = src[i];
   dst[i] = '\0';
 }
 
 // Inverse-video multiplier chip ("x2"/"x3") — the group-bonus indicator on the
 // FINDER and POINTS headers. Draws right-aligned ending at `right_x` in the
 // header band (y 0..8); nothing at mult<2. Returns the horizontal space taken
 // (width + gap) so callers can keep right-stacking header elements.
 static int draw_mult_chip(int right_x, uint8_t mult) {
   if (mult < 2) return 0;
   char t[4];
   snprintf(t, sizeof(t), "x%u", (unsigned)mult);
   int w = u8g2.getStrWidth(t) + 4;          // 2px pad each side
   u8g2.drawRBox(right_x - w, 0, w, 9, 1);
   u8g2.setDrawColor(0);                     // cut the label out of the box
   u8g2.drawStr(right_x - w + 2, 7, t);
   u8g2.setDrawColor(1);
   return w + 3;
 }
 
 // 4-segment signal bar (like a phone), filled to the RSSI level. Inactive slots
 // render as a 1px base stub, NOT an outline: the bars are only 2px wide, and a
 // 2px-wide drawFrame() is just its left+right edges — i.e. both columns — so it
 // is indistinguishable from a filled box. (That bug made every bar look full.)
 static void draw_bars(int x, int baseline, int8_t rssi) {
   int lvl = rssi >= -55 ? 4 : rssi >= -65 ? 3 : rssi >= -75 ? 2 : rssi >= -85 ? 1 : 0;
   for (int i = 0; i < 4; i++) {
     int h = 2 + i * 2;
     int bx = x + i * 3;
     if (i < lvl) u8g2.drawBox(bx, baseline - h, 2, h);  // filled to level
     else         u8g2.drawBox(bx, baseline - 1, 2, 1);  // empty: base stub
   }
 }
 
 // Line plot of the points samples in the box (x,y)-(x+w,y+h). Y auto-scales to
 // the window's [min,max] points (flat series → baseline). X is real wall-clock
 // over the fixed POINTS_GRAPH_SPAN_S window (anchored at the oldest sample) when
 // the clock is synced; otherwise it falls back to uniform spacing. A sample
 // flagged seg_start (the first after a reboot) breaks the line — the badge has
 // no RTC so we mark the discontinuity without sizing the off-period.
 // Plots samples within a time window: span_s wide, anchored at `anchor` (epoch).
 // 5-day view → span=5d, anchor=oldest sample (all samples shown). 24h view →
 // span=24h, anchor=newest−24h (only the last day shown, Y rescaled to it). When
 // the clock was never synced, falls back to uniform spacing over all samples.
 static void draw_sparkline(int x, int y, int w, int h, const PointSample* v, int n,
                            uint32_t span_s, uint32_t anchor, bool synced) {
   if (n < 1) return;
   // First pass: in-window count + Y range (in-window = epoch ≥ anchor, or all if unsynced).
   int inwin = 0; bool any = false; uint16_t mn = 0, mx = 0;
   for (int i = 0; i < n; i++) {
     if (synced && v[i].epoch < anchor) continue;
     inwin++;
     if (!any) { mn = mx = v[i].points; any = true; }
     else { if (v[i].points < mn) mn = v[i].points; if (v[i].points > mx) mx = v[i].points; }
   }
   if (!any) return;
   uint32_t yspan = (uint32_t)mx - mn;
   int prevx = 0, prevy = 0; bool first = true; int idx = 0;
   for (int i = 0; i < n; i++) {
     if (synced && v[i].epoch < anchor) continue;
     int px;
     if (synced) {
       uint32_t dt = (v[i].epoch > anchor) ? (v[i].epoch - anchor) : 0;
       if (dt > span_s) dt = span_s;
       px = x + (int)(dt * (uint32_t)(w - 1) / span_s);
     } else {
       px = x + (inwin == 1 ? 0 : (idx * (w - 1)) / (inwin - 1));
     }
     int py = yspan == 0 ? (y + h - 1)
                         : (y + (h - 1) - (int)(((uint32_t)(v[i].points - mn) * (h - 1)) / yspan));
     if (first || v[i].seg_start) u8g2.drawPixel(px, py);   // segment break
     else                         u8g2.drawLine(prevx, prevy, px, py);
     prevx = px; prevy = py; first = false; idx++;
   }
 }
 
 // I2C bus recovery — un-stick a wedged bus before init. If the ESP32 was reset
 // via EN mid-transaction (a serial-monitor/OTA reset, or the physical RST button:
 // EN resets the MCU but NOT the OLED, which stays powered on 3V3), the SSD1309 can
 // be left holding SDA low. The hardware-I2C driver then returns ESP_ERR_INVALID_STATE
 // on every write and the panel stays dark until a full power-cycle. Clock SCL up to
 // 9 times to let the slave finish its hung byte + ACK and release SDA, then issue a
 // STOP. Bit-banged before u8g2.begin() claims the pins. No-op on a healthy bus.
 static void i2c_bus_recover() {
   pinMode(OLED_SDA_PIN, INPUT_PULLUP);
   pinMode(OLED_SCL_PIN, OUTPUT);
   for (int i = 0; i < 9 && digitalRead(OLED_SDA_PIN) == LOW; i++) {
     digitalWrite(OLED_SCL_PIN, HIGH); delayMicroseconds(5);   // ~100kHz, matches the driver
     digitalWrite(OLED_SCL_PIN, LOW);  delayMicroseconds(5);
   }
   // STOP: SDA rises while SCL is high.
   pinMode(OLED_SDA_PIN, OUTPUT);
   digitalWrite(OLED_SDA_PIN, LOW);  delayMicroseconds(5);
   digitalWrite(OLED_SCL_PIN, HIGH); delayMicroseconds(5);
   digitalWrite(OLED_SDA_PIN, HIGH); delayMicroseconds(5);
   // Release both lines; u8g2.begin() re-inits the hardware I2C peripheral on these pins.
   pinMode(OLED_SDA_PIN, INPUT_PULLUP);
   pinMode(OLED_SCL_PIN, INPUT_PULLUP);
 }
 
 void display_init() {
   i2c_bus_recover();     // un-wedge a bus left stuck by an EN-only reset before init
   u8g2.begin();
   u8g2.setFont(ROW_FONT);
 }
 
 // Deep-sleep companion: SSD1309 display-off (sleep mode). Blanking the buffer would NOT
 // do — an all-black frame still runs the panel's charge pump and draws nearly full
 // current. setPowerSave(1) is the register write that actually stops it.
 void display_sleep() {
   u8g2.setPowerSave(1);
 }
 
 // Level index → SSD1309 contrast register. u8g2's begin() already programs
 // OLED_BRIGHT_MED as part of the SSD1309 init sequence, so an unset/invalid level
 // lands on the panel's pre-existing look rather than a surprise.
 void display_set_brightness(uint8_t level) {
   static const uint8_t kContrast[SCREEN_BRIGHT_LEVELS] =
       { OLED_BRIGHT_LOW, OLED_BRIGHT_MED, OLED_BRIGHT_HIGH };
   if (level >= SCREEN_BRIGHT_LEVELS) level = SCREEN_BRIGHT_DEFAULT;
   u8g2.setContrast(kContrast[level]);
 }
 
 void display_boot(const char* line) {
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr(0, 12, "friend-finder");
   u8g2.drawStr(0, 28, line);
   u8g2.sendBuffer();
 }
 
 // Heat + LiPo-safety disclaimer, shown once at boot (after the splash). A static text
 // card; blocking — it holds itself on screen for DISCLAIMER_HOLD_MS × BOOT_TIMING_SCALE
 // (boot only) then returns. Header in the 6x10 row font; the body uses the smaller 5x7
 // font (25 chars/line vs 21) so the full note fits the 128px width. ASCII-only.
 void display_disclaimer() {
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr(0, 8, "// WARNING");
   u8g2.drawHLine(0, 11, 128);
   u8g2.setFont(u8g2_font_5x7_tf);                    // body: 5px/char → 25 fit vs 21
   u8g2.drawStr(0, 22, "This badge runs on a LIPO");
   u8g2.drawStr(0, 32, "battery. We're in Vegas.");
   u8g2.drawStr(0, 42, "Keep an eye on how hot");
   u8g2.drawStr(0, 52, "it gets. Spicy pillow?");
   u8g2.drawStr(0, 62, "Discontinue use.");
   u8g2.sendBuffer();
   u8g2.setFont(ROW_FONT);                            // restore the default for later screens
   delay((uint32_t)DISCLAIMER_HOLD_MS * BOOT_TIMING_SCALE);
 }
 
 // ─── Boot splash animations ──────────────────────────────────────────────────
 // One of the BOOT_SPLASH_COUNT styles plays once at power-on (BOOT_SPLASH_* in
 // config.h). All are blocking — they run in setup() before any mode screen.
 
 // Final resting frame shared by radar + glitch: wordmark + signal-bar flourish.
 static void splash_wordmark() {
   u8g2.clearBuffer();
   u8g2.setFont(u8g2_font_7x13B_tf);
   const char* t = "FRIEND-FINDER";
   u8g2.drawStr((128 - u8g2.getStrWidth(t)) / 2, 24, t);
   const int bx = 40, by = 46;                     // rising bars, centered
   for (int i = 0; i < 8; i++) { int h = 2 + i; u8g2.drawBox(bx + i * 6, by - h, 4, h); }
   u8g2.setFont(ROW_FONT);
   char v[ROW_CHARS + 1];
   snprintf(v, sizeof(v), "%s ch%d", FW_BUILD_STR, ESPNOW_CHANNEL);   // version + rev + channel
   u8g2.drawStr((128 - u8g2.getStrWidth(v)) / 2, 62, v);
   u8g2.sendBuffer();
   delay(500 * BOOT_TIMING_SCALE);
 }
 
 // Style 0 — sonar sweep around a scope; crew "blips" ping in as the sweep passes
 // them, then it resolves to the wordmark. Mirrors what the badge does.
 static void splash_radar() {
   const int cx = 64, cy = 31, R = 30;
   const float D2R = 0.017453293f;
   struct { int deg, r; } blip[] = { {55, 18}, {140, 27}, {235, 12}, {310, 23} };
   const int NB = 4;
   bool found[NB] = { false, false, false, false };
   for (int s = 0; s <= 540; s += 12) {            // 1.5 sweeps
     float a = (s - 90) * D2R;
     u8g2.clearBuffer();
     u8g2.drawCircle(cx, cy, R);
     u8g2.drawCircle(cx, cy, R * 2 / 3);
     u8g2.drawPixel(cx, cy);
     u8g2.drawLine(cx, cy, cx + (int)(R * cosf(a)), cy + (int)(R * sinf(a)));
     for (int i = 0; i < NB; i++) {
       if (s >= blip[i].deg) found[i] = true;      // discovered as the sweep crosses it
       if (found[i]) {
         float ba = (blip[i].deg - 90) * D2R;
         u8g2.drawDisc(cx + (int)(blip[i].r * cosf(ba)), cy + (int)(blip[i].r * sinf(ba)), 2);
       }
     }
     u8g2.sendBuffer();
     delay(22 * BOOT_TIMING_SCALE);
   }
   splash_wordmark();
 }
 
 // Style 1 — POST-style typewriter self-test, revealed line by line, char by char.
 static void splash_terminal() {
   char l0[32];
   snprintf(l0, sizeof(l0), "./friend-finder_%d_%d.sh",           // banner = "run" the versioned binary
            FW_VERSION_MAJOR, FW_VERSION_MINOR);
   char lb[32];
   snprintf(lb, sizeof(lb), "> beacon  ... ch %d", ESPNOW_CHANNEL);  // read the define, never hardcode it:
                                                                     //   the POST used to claim "ch 1" no
                                                                     //   matter what the radio actually did
   const char* L[] = {
     l0, "> radio   ..... OK", "> crypto  ..... OK",
     "> fs      ..... OK", "> clock   .... SET", lb,
     "badge online",
   };
   const int NL = 7;
   u8g2.setFont(u8g2_font_5x8_tf);
   char shown[8][24];
   for (int i = 0; i < NL; i++) shown[i][0] = '\0';
   for (int i = 0; i < NL; i++) {
     int len = (int)strlen(L[i]);
     for (int c = 1; c <= len; c++) {
       strncpy(shown[i], L[i], c); shown[i][c] = '\0';
       u8g2.clearBuffer();
       for (int j = 0; j <= i; j++) u8g2.drawStr(2, 9 + j * 8, shown[j]);
       u8g2.drawBox(2 + c * 5, 9 + i * 8 - 7, 4, 8);   // blinking-ish cursor block
       u8g2.sendBuffer();
       delay(7 * BOOT_TIMING_SCALE);
     }
   }
   delay(350 * BOOT_TIMING_SCALE);
 }
 
 // Style 2 — wordmark assembles out of scanline noise, then the bars sweep in.
 static void splash_glitch() {
   randomSeed(micros());
   const char* t1 = "FRIEND";
   const char* t2 = "FINDER";
   u8g2.setFont(u8g2_font_8x13B_tf);
   for (int f = 0; f < 22; f++) {
     u8g2.clearBuffer();
     int jx = (f < 16) ? (int)random(-3, 4) : 0;       // jitter settles late
     u8g2.drawStr((128 - u8g2.getStrWidth(t1)) / 2 + jx, 24, t1);
     u8g2.drawStr((128 - u8g2.getStrWidth(t2)) / 2 - jx, 40, t2);
     int noise = 120 - f * 6; if (noise < 0) noise = 0; // thinning static
     for (int i = 0; i < noise; i++) u8g2.drawPixel(random(0, 128), random(0, 64));
     u8g2.sendBuffer();
     delay(28 * BOOT_TIMING_SCALE);
   }
   for (int k = 1; k <= 8; k++) {                       // bars sweep in
     u8g2.clearBuffer();
     u8g2.setFont(u8g2_font_8x13B_tf);
     u8g2.drawStr((128 - u8g2.getStrWidth(t1)) / 2, 24, t1);
     u8g2.drawStr((128 - u8g2.getStrWidth(t2)) / 2, 40, t2);
     for (int i = 0; i < k; i++) { int h = 2 + i; u8g2.drawBox(40 + i * 6, 60 - h, 4, h); }
     u8g2.sendBuffer();
     delay(35 * BOOT_TIMING_SCALE);
   }
   delay(250 * BOOT_TIMING_SCALE);
 }
 
 // Style 3 — glyph rain: columns of falling characters, each with a bright head and a
 // trail that fades out behind it, resolving to the wordmark. The alphabet is just the
 // letters of "onlyn00bs" (so 'n' and '0' fall twice as often, which suits the wordmark).
 //
 // The panel is 1-bit, so a real brightness ramp down the trail isn't available. Depth is
 // faked with three tiers instead: the head is drawn INVERSE (a filled cell with the glyph
 // knocked out of it, the brightest thing on screen), the body is plain glyphs, and the
 // last two cells get alternate scanlines knocked out — a 50% dither that reads as dim.
 static void splash_matrix() {
   static const char GLYPHS[] = "onlyn00bs";
   const int NG   = (int)sizeof(GLYPHS) - 1;
   const int CW   = 5, CH = 8;               // 5x7 font in a 5x8 cell
   const int COLS = 128 / CW;                // 25 columns (125px; 3px slack at the right)
   const int ROWS = 64 / CH;                 // 8 rows
 
   // Position is 1/16th-row fixed point so columns can fall at different sub-row speeds;
   // stepping in whole rows would make every column move in lockstep. static, not stack:
   // this is ~250B and setup()'s stack has better uses.
   static int16_t pos[COLS];                 // head position, 1/16 row units (negative = above screen)
   static uint8_t vel[COLS];                 // fall rate in the same units per frame
   static uint8_t len[COLS];                 // trail length, cells
   static uint8_t cell[COLS][ROWS];          // which glyph sits in each grid cell
 
   randomSeed(micros());
   for (int c = 0; c < COLS; c++) {
     pos[c] = -(int16_t)random(0, ROWS * 16 * 2);   // stagger entry so they don't arrive as a wall
     vel[c] = 3 + random(0, 8);                     // ~0.2–0.6 rows/frame
     len[c] = 3 + random(0, ROWS - 2);
     for (int r = 0; r < ROWS; r++) cell[c][r] = random(0, NG);
   }
 
   u8g2.setFont(u8g2_font_5x7_tf);
   for (int f = 0; f < 46; f++) {
     u8g2.clearBuffer();
     for (int c = 0; c < COLS; c++) {
       int head = pos[c] >> 4;
       for (int t = 0; t < len[c]; t++) {
         int r = head - t;
         if (r < 0 || r >= ROWS) continue;
         int x = c * CW, ytop = r * CH;
         char s[2] = { GLYPHS[cell[c][r]], '\0' };
         if (t == 0) {                              // head — inverse cell
           u8g2.drawBox(x, ytop, CW, CH);
           u8g2.setDrawColor(0);
           u8g2.drawStr(x, ytop + 7, s);
           u8g2.setDrawColor(1);
         } else {
           u8g2.drawStr(x, ytop + 7, s);
           if (t >= len[c] - 2) {                   // tail — dither to half density
             u8g2.setDrawColor(0);
             for (int yy = ytop; yy < ytop + CH; yy += 2) u8g2.drawHLine(x, yy, CW);
             u8g2.setDrawColor(1);
           }
         }
       }
       pos[c] += vel[c];
       if ((pos[c] >> 4) - len[c] >= ROWS) {        // whole trail cleared the bottom → respawn
         pos[c] = -(int16_t)random(0, ROWS * 16);
         vel[c] = 3 + random(0, 8);
         len[c] = 3 + random(0, ROWS - 2);
       }
       if (random(0, 6) == 0)                       // shimmer: without this the columns just
         cell[c][random(0, ROWS)] = random(0, NG);  //   scroll rigidly and it reads as a texture
     }
     u8g2.sendBuffer();
     delay(22 * BOOT_TIMING_SCALE);                 // same frame budget as the radar sweep
   }
   splash_wordmark();
 }
 
 void display_boot_splash(int style) {
   switch (style) {
     case BOOT_SPLASH_TERMINAL: splash_terminal(); break;
     case BOOT_SPLASH_GLITCH:   splash_glitch();   break;
     case BOOT_SPLASH_MATRIX:   splash_matrix();   break;
     case BOOT_SPLASH_RADAR:
     default:                   splash_radar();    break;
   }
   delay(1000);                                     // hold the final splash frame 1s longer
   u8g2.setFont(ROW_FONT);                          // restore default for later screens
 }
 
 // The boot logo card: full-screen frames, each mark centred on the whole 128×64 panel.
 // That's the only arrangement where these marks stay legible — a denser single-frame
 // layout was tried on glass and rejected (see config.h). Geometry comes from the W/H that
 // logos.h carries, so re-baking at a different size needs no change here.
 //
 // The set is currently the wordmark alone. LOGO_EMBLEM_* and LOGO_FOOT_* are still baked
 // into logos.h, so restoring either is one more entry in this array — the per-frame hold
 // divides the fixed budget, so boot time won't move when you do.
 void display_boot_logos() {
   static const struct { const unsigned char* bits; uint8_t w, h; } card[] = {
     { LOGO_ONLYNOOBS_BITS, LOGO_ONLYNOOBS_W, LOGO_ONLYNOOBS_H },
   };
   const uint8_t n = sizeof(card) / sizeof(card[0]);
   for (uint8_t i = 0; i < n; i++) {
     u8g2.clearBuffer();
     u8g2.drawXBMP((128 - card[i].w) / 2, (64 - card[i].h) / 2,
                   card[i].w, card[i].h, card[i].bits);
     u8g2.sendBuffer();
     delay(BOOT_LOGO_TOTAL_MS / n);
   }
   u8g2.setFont(ROW_FONT);                          // restore default for later screens
 }
 
 void display_provisioning(const char* device_name, const char* code) {
   char buf[32];
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr(0, 10, "SETUP MODE");
   u8g2.setFont(u8g2_font_5x8_tf);            // 5px wide → the full badge-setup-<MAC> name fits one line
   truncate(buf, device_name, 25);            // 25 * 5px = 125 < 128
   u8g2.drawStr(0, 21, buf);
   // pairing code — big, the web app needs it to unlock provisioning
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr(0, 41, "code:");
   u8g2.setFont(u8g2_font_9x18B_tf);
   u8g2.drawStr(36, 43, code);
   u8g2.setFont(u8g2_font_5x8_tf);
   // The escape hatch wins this line over the old "enter code in the app". The code is
   // already labelled above and the web app tells you what to do with it, but nothing
   // else on the device tells you setup mode can be left — and it never times out.
   // 25 chars exactly: 25 * 5px = 125 < 128.
   u8g2.drawStr(0, 60, "hold BTN 5s to exit setup");
   u8g2.sendBuffer();
 }
 
 void display_peers(const char* my_handle, const Peer* peers, int n, bool show_rssi,
                    uint8_t mult, int page) {
   (void)my_handle;                        // OLED header is a static title, like the other views
   char buf[ROW_CHARS + 1];
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
 
   // Paginate: FINDER_PAGE_ROWS closest peers per screen. Clamp defensively (main.cpp
   // already clamps as peers leave, but never trust the caller for indexing).
   int pages = (n + FINDER_PAGE_ROWS - 1) / FINDER_PAGE_ROWS;
   if (pages < 1) pages = 1;
   if (page >= pages) page = pages - 1;
   if (page < 0)     page = 0;
   int start = page * FINDER_PAGE_ROWS;
   int end   = n < start + FINDER_PAGE_ROWS ? n : start + FINDER_PAGE_ROWS;
 
   // header: "// finder" title + right-aligned "(N)" peer count, plus a "p/P" page tag
   // (only when there's more than one page). The inverse multiplier chip sits left of it
   // when a group bonus is active. (Column mode lives in User Settings → Finder View.)
   u8g2.drawStr(0, 8, "// finder");
   if (pages > 1) snprintf(buf, sizeof(buf), "(%d) %d/%d", n, page + 1, pages);
   else           snprintf(buf, sizeof(buf), "(%d)", n);
   int rw = u8g2.getStrWidth(buf);
   u8g2.drawStr(128 - rw, 8, buf);
   draw_mult_chip(128 - rw - 3, mult);
   u8g2.drawHLine(0, 11, 128);
 
   if (n == 0) {
     u8g2.drawStr(0, 30, "nobody in range");
     u8g2.sendBuffer();
     return;
   }
 
   for (int i = start; i < end; i++) {     // this page's slice (≤ FINDER_PAGE_ROWS rows)
     int y = 23 + (i - start) * 10;        // baselines: 23,33,43,53,63
     draw_bars(0, y, peers[i].rssi);
     // right column toggles between the peer's pet face and signed dBm; the bars
     // always show signal, so the column is free to carry the pet by default.
     char rcol[PET_FACE_MAX + 1];
     if (show_rssi) snprintf(rcol, sizeof(rcol), "%d", peers[i].rssi);
     else           truncate(rcol, peers[i].pet_face, 8);
     int rcol_w = u8g2.getStrWidth(rcol);
     u8g2.drawStr(128 - rcol_w, y, rcol);
     // handle fills whatever's left between the bars and the right column
     int maxch = (128 - rcol_w - 2 - 16) / 6;
     if (maxch > ROW_CHARS) maxch = ROW_CHARS;
     if (maxch < 0) maxch = 0;
     truncate(buf, peers[i].handle, maxch);
     u8g2.drawStr(16, y, buf);
   }
   u8g2.sendBuffer();
 }
 
 static void fmt_dur(uint32_t s, char* out, size_t n) {
   uint32_t h = s / 3600, m = (s % 3600) / 60;
   if (h) snprintf(out, n, "%uh%02um", (unsigned)h, (unsigned)m);
   else   snprintf(out, n, "%um", (unsigned)m);
 }
 
 void display_report(const char* my_handle, const Report& r) {
   char buf[ROW_CHARS + 1], dur[16];
   (void)my_handle;
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
 
   u8g2.drawStr(0, 8, "// con report");
   if (!r.time_synced) {                       // relative times → nudge a clock re-sync
     const char* tag = "resync";
     u8g2.drawStr(128 - u8g2.getStrWidth(tag), 8, tag);
   }
   u8g2.drawHLine(0, 11, 128);
 
   fmt_dur(r.total_seconds, dur, sizeof(dur));
   snprintf(buf, sizeof(buf), "%df %dx %s", r.unique, r.total_encounters, dur);
   u8g2.drawStr(0, 23, buf);
 
   int shown = r.n < 4 ? r.n : 4;          // top 4 friends
   for (int i = 0; i < shown; i++) {
     int y = 35 + i * 10;                  // 35,45,55,(63)
     if (y > 63) break;
     fmt_dur(r.friends[i].total_seconds, dur, sizeof(dur));
     char name[15];
     truncate(name, r.friends[i].handle, 11);
     snprintf(buf, sizeof(buf), "%-11s x%u %s", name,
              (unsigned)r.friends[i].encounters, dur);
     u8g2.drawStr(0, y, buf);
   }
   u8g2.sendBuffer();
 }
 
 void display_points(const char* my_handle, uint32_t points,
                     uint32_t prox_seconds, int peers_now, bool earning,
                     const PointSample* hist, int hist_n,
                     uint32_t graph_span_s, const char* window_label, bool anchor_newest,
                     uint8_t mult, bool stealth) {
   char buf[ROW_CHARS + 1];
   (void)my_handle;
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
 
   // header: "// points" + window tag + [x2 chip] + right-aligned score. The graph
   // owns the body now, so the score lives up here instead of as the big number.
   u8g2.drawStr(0, 8, "// points");
   u8g2.drawStr(60, 8, window_label);
   snprintf(buf, sizeof(buf), "%up", (unsigned)points);
   int sw = u8g2.getStrWidth(buf);
   u8g2.drawStr(128 - sw, 8, buf);
   draw_mult_chip(128 - sw - 3, mult);
   u8g2.drawHLine(0, 11, 128);
 
   // points-over-time line graph fills the middle band (y 14..50)
   if (hist_n >= 2) {
     bool synced = (hist[hist_n - 1].epoch != 0);
     uint32_t anchor = (anchor_newest && synced && hist[hist_n - 1].epoch > graph_span_s)
                         ? hist[hist_n - 1].epoch - graph_span_s : hist[0].epoch;
     draw_sparkline(0, 14, 128, 37, hist, hist_n, graph_span_s, anchor, synced);
   } else {
     u8g2.drawStr(0, 34, "collecting graph...");
   }
 
   // status line: live countdown when earning, else why we're paused. With a
   // group bonus the tally ticks ×mult per wall second, so the wall-clock wait
   // to the next point is the remainder ÷ mult (rounded up).
   if (earning) {
     uint32_t rem = 60 - prox_seconds % 60;
     if (mult > 1) rem = (rem + mult - 1) / mult;
     snprintf(buf, sizeof(buf), "+1 pt in %us", (unsigned)rem);
   }
   else if (stealth)                      // check first: crew can be right here and in-gate,
     snprintf(buf, sizeof(buf), "paused  stealth on");   // so "too far" would be a lie
   else if (peers_now > 0)
     snprintf(buf, sizeof(buf), "paused  crew too far");
   else
     snprintf(buf, sizeof(buf), "paused  no crew");
   u8g2.drawStr(0, 62, buf);
 
   u8g2.sendBuffer();
 }
 
 void display_battery(const char* my_handle, uint16_t mv, uint8_t pct, bool low) {
   char buf[ROW_CHARS + 1];
   (void)my_handle;
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
 
   // header: "// battery               LOW!"
   u8g2.drawStr(0, 8, "// battery");
   if (low) {
     const char* w = "LOW!";
     u8g2.drawStr(128 - u8g2.getStrWidth(w), 8, w);
   }
   u8g2.drawHLine(0, 11, 128);
 
   // big percentage, centered (digit font for the number + small "%" after it)
   snprintf(buf, sizeof(buf), "%u", (unsigned)pct);
   u8g2.setFont(u8g2_font_logisoso28_tn);
   int pw = u8g2.getStrWidth(buf);
   u8g2.setFont(ROW_FONT);
   int sw = u8g2.getStrWidth("%");
   int px = (128 - (pw + 3 + sw)) / 2;                 // center the "XX%" block
   u8g2.setFont(u8g2_font_logisoso28_tn);
   u8g2.drawStr(px, 44, buf);
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr(px + pw + 3, 44, "%");
 
   // voltage on the right, e.g. "3.85V"
   snprintf(buf, sizeof(buf), "%u.%02uV", mv / 1000, (mv % 1000) / 10);
   u8g2.drawStr(128 - u8g2.getStrWidth(buf), 30, buf);
 
   // full-width charge bar along the bottom
   const int bx = 0, by = 52, bw = 128, bh = 11;
   u8g2.drawFrame(bx, by, bw, bh);
   int fill = (int)((long)(bw - 2) * pct / 100);
   if (fill > 0) u8g2.drawBox(bx + 1, by + 1, fill, bh - 2);
 
   u8g2.sendBuffer();
 }
 
 // "742K" / "1.2M" / "60B" — a compact size for the 128px-wide readout.
 static void fmt_bytes(size_t b, char* out, size_t n) {
   if      (b >= 1024UL * 1024UL) snprintf(out, n, "%u.%uM", (unsigned)(b >> 20),
                                           (unsigned)((((b >> 10) & 1023) * 10) >> 10));
   else if (b >= 1024UL)          snprintf(out, n, "%uK", (unsigned)(b >> 10));
   else                           snprintf(out, n, "%uB", (unsigned)b);
 }
 
 // Deliberately the same furniture as display_battery (header + big centred %, a figure on
 // the right, a full-width bar) — it's the same view under a single tap, so it should read
 // as one. It does invert the battery's polarity, though: a disk bar fills as the disk
 // fills, per convention, so the number and the bar both report USED while the battery face
 // reports what's left. Free space is still carried by the "871K free" label on the right.
 void display_storage(const char* my_handle, size_t used, size_t total, bool full) {
   char buf[ROW_CHARS + 1], sz[12];
   (void)my_handle;
   size_t freeb = (total > used) ? total - used : 0;
   // Drives BOTH the big number and the bar, so they can never disagree.
   uint8_t pct  = total ? (uint8_t)((uint64_t)used * 100 / total) : 0;    // % USED
 
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
 
   // header: "// storage               FULL!"
   u8g2.drawStr(0, 8, "// storage");
   if (full) {
     const char* w = "FULL!";
     u8g2.drawStr(128 - u8g2.getStrWidth(w), 8, w);
   }
   u8g2.drawHLine(0, 11, 128);
 
   // big used percentage, centered (digit font for the number + small "%" after it)
   snprintf(buf, sizeof(buf), "%u", (unsigned)pct);
   u8g2.setFont(u8g2_font_logisoso28_tn);
   int pw = u8g2.getStrWidth(buf);
   u8g2.setFont(ROW_FONT);
   int sw = u8g2.getStrWidth("%");
   int px = (128 - (pw + 3 + sw)) / 2;                 // center the "XX%" block
   u8g2.setFont(u8g2_font_logisoso28_tn);
   u8g2.drawStr(px, 44, buf);
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr(px + pw + 3, 44, "%");
 
   // free space on the right, e.g. "742K free" — the remaining-space figure the % no longer carries
   fmt_bytes(freeb, sz, sizeof(sz));
   snprintf(buf, sizeof(buf), "%s free", sz);
   u8g2.drawStr(128 - u8g2.getStrWidth(buf), 30, buf);
 
   // full-width usage bar along the bottom — fills as the disk fills
   const int bx = 0, by = 52, bw = 128, bh = 11;
   u8g2.drawFrame(bx, by, bw, bh);
   int fill = (int)((long)(bw - 2) * pct / 100);
   if (fill > 0) u8g2.drawBox(bx + 1, by + 1, fill, bh - 2);
 
   u8g2.sendBuffer();
 }
 
 void display_friends(const char* my_handle, const PointFriend* top, int n,
                      uint32_t total_points) {
   char buf[ROW_CHARS + 1], name[16];
   (void)my_handle;
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
 
   u8g2.drawStr(0, 8, "// best friends");
   u8g2.drawHLine(0, 11, 128);
 
   if (n == 0) {
     u8g2.drawStr(0, 30, "no points yet");
     u8g2.sendBuffer();
     return;
   }
 
   int shown = n < 3 ? n : 3;              // podium: top 3
   for (int i = 0; i < shown; i++) {
     int y = 24 + i * 12;                  // baselines 24,36,48
     truncate(name, top[i].handle, 14);
     snprintf(buf, sizeof(buf), "%d %s", i + 1, name);
     u8g2.drawStr(0, y, buf);
     snprintf(buf, sizeof(buf), "%u", (unsigned)(top[i].seconds / 60));
     u8g2.drawStr(128 - u8g2.getStrWidth(buf), y, buf);   // points, right-aligned
   }
 
   snprintf(buf, sizeof(buf), "of %u pts total", (unsigned)total_points);
   u8g2.drawStr(0, 62, buf);
   u8g2.sendBuffer();
 }
 
 void display_pet(const char* name, const char* face) {
   char buf[ROW_CHARS + 1];
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
   snprintf(buf, sizeof(buf), "// %s", name);
   u8g2.drawStr(0, 8, buf);
   u8g2.drawHLine(0, 11, 128);
   // big ASCII face, centered in the body
   u8g2.setFont(u8g2_font_9x18B_tf);
   u8g2.drawStr((128 - u8g2.getStrWidth(face)) / 2, 40, face);
   // "tap to swap" hint (points/peers readout removed)
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr(128 - u8g2.getStrWidth("tap:swap"), 62, "tap:swap");
   u8g2.sendBuffer();
 }
 
 // Tiny battery glyph (11×7 body + 2px terminal nub); inner fill ∝ pct. Top-left at (x,y).
 static void draw_batt_glyph(int x, int y, uint8_t pct) {
   u8g2.drawFrame(x, y, 11, 7);                    // body outline
   u8g2.drawBox(x + 11, y + 2, 2, 3);              // + terminal nub on the right
   uint8_t fw = (uint8_t)((pct * 9 + 50) / 100);   // inner fill width 0..9 (rounded)
   if (fw) u8g2.drawBox(x + 1, y + 1, fw, 5);      // fill from the left
 }
 
 // Tiny floppy-disk glyph — 9×7 static, matching the battery glyph's height. Shutter on top,
 // label below, both permanent:
 //     #########
 //     #..###..#   shutter
 //     #..###..#
 //     #.......#
 //     #.#####.#   label
 //     #.#####.#
 //     #########
 // Deliberately NOT a fill gauge. A proportional fill failed at both ends: at a realistic 3%
 // used it left the label blank — an empty box with a slot, unreadable as a disk — and near
 // full it swallowed the icon into a blob. There are only ~35 interior pixels here, not enough
 // to be an icon AND a gauge, and the adjacent "%" text already carries the number. So the
 // glyph's one job is to say "disk". Hand-drawn rather than Open Iconic: the smallest iconic
 // size (1x) is 8×8 and overflows this 7px band. Top-left at (x,y).
 static void draw_disk_glyph(int x, int y) {
   u8g2.drawFrame(x, y, 9, 7);                     // disk body
   u8g2.drawBox(x + 3, y + 1, 3, 2);               // shutter, top-centre
   u8g2.drawBox(x + 2, y + 4, 5, 2);               // label
 }
 
 void display_home(const char* handle, const char* face, uint32_t points,
                   uint8_t batt_pct, bool batt_low, uint8_t disk_pct, const char* clock_str,
                   bool radio_on) {
   char buf[ROW_CHARS + 1], name[20];
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
 
   // header: "// home" (left), then disk glyph + % and battery glyph + % (right). Clock retired.
   (void)clock_str;   // wall-clock display being retired
   u8g2.drawStr(0, 8, "// home");
   // battery: glyph + %, right-aligned. When low: a steady "!" after the % + a slow glyph blink.
   snprintf(buf, sizeof(buf), "%u%%%s", (unsigned)batt_pct, batt_low ? "!" : "");
   int pw = u8g2.getStrWidth(buf);
   u8g2.drawStr(128 - pw, 8, buf);                      // percentage (+ "!" when low) at the far right
   int batt_x = 128 - pw - 15;                          // 13px glyph + 2px gap. Computed even while the
                                                        //   glyph is blinked off, so storage never shifts.
   if (!batt_low || (millis() / BATT_LOW_BLINK_MS) % 2 == 0)
     draw_batt_glyph(batt_x, 2, batt_pct);              // blinks while low
   // storage: glyph + % used, parked left of the battery block. Worst realistic case (both
   // reading 100%) still clears the "// home" title by ~8px.
   snprintf(buf, sizeof(buf), "%u%%", (unsigned)disk_pct);
   int dw = u8g2.getStrWidth(buf);
   u8g2.drawStr(batt_x - 4 - dw, 8, buf);               // 4px gap between the two blocks
   draw_disk_glyph(batt_x - 4 - dw - 11, 2);            // 9px glyph + 2px gap; the % text is the readout
   u8g2.drawHLine(0, 11, 128);
 
   // username — prominent, centered
   truncate(name, handle, 18);
   u8g2.setFont(u8g2_font_7x13B_tf);
   u8g2.drawStr((128 - u8g2.getStrWidth(name)) / 2, 28, name);
 
   // pet face (left) + total points (right), sharing the middle band
   u8g2.setFont(u8g2_font_9x18B_tf);
   u8g2.drawStr(4, 48, face);
   u8g2.setFont(ROW_FONT);
   snprintf(buf, sizeof(buf), "%u pts", (unsigned)points);
   u8g2.drawStr(128 - u8g2.getStrWidth(buf), 46, buf);
 
   // Stealth tell, in the free band under the face/points row. Inverse so it can't be
   // mistaken for a stat, and named for the mode rather than the failure so it reads as
   // deliberate. The header is already full (title + disk + battery) and its worst case
   // leaves ~6px, so this lives down here where nothing can collide with it.
   if (!radio_on) {
     const char* lbl = "STEALTH";
     int tw = u8g2.getStrWidth(lbl);
     int bw = tw + 6;                                   // 3px pad each side
     u8g2.drawRBox((128 - bw) / 2, 53, bw, 11, 1);
     u8g2.setDrawColor(0);                              // cut the label out of the box
     u8g2.drawStr((128 - tw) / 2, 62, lbl);
     u8g2.setDrawColor(1);
   }
 
   u8g2.sendBuffer();
 }
 
 // Factory-reset confirmation. Body in the 5x7 font (25 chars/line vs 21) so the list of
 // what actually gets destroyed fits without abbreviating it into uselessness.
 void display_reset_confirm(int cursor) {
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr(0, 8, "// factory reset");
   u8g2.drawHLine(0, 11, 128);
   u8g2.setFont(u8g2_font_5x7_tf);
   u8g2.drawStr(0, 21, "Erases your handle,");
   u8g2.drawStr(0, 30, "avatar, points, log");
   u8g2.drawStr(0, 39, "and settings. Undo: no.");
   u8g2.setFont(ROW_FONT);
   static const char* opt[2] = { "Cancel", "ERASE" };     // Cancel first = the default row
   for (int i = 0; i < 2; i++) {
     int y = 50 + i * 11;                                 // 50 → 43..52, 61 → 54..63; fits 64px
     if (i == cursor) u8g2.drawStr(2, y, ">");
     u8g2.drawStr(14, y, opt[i]);
   }
   u8g2.sendBuffer();
 }
 
 void display_menu(int splash_sel) {
   static const char* names[BOOT_SPLASH_COUNT] = { "radar", "terminal", "glitch", "matrix" };
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr(0, 8, "// boot splash");
   u8g2.drawHLine(0, 11, 128);
   // 22/10 rather than the old 24/11: with a 4th style the last row's baseline landed at 57
   // (glyphs 50..59) and collided with the "tap: change" hint at 62 (55..64). This clears it.
   for (int i = 0; i < BOOT_SPLASH_COUNT; i++) {
     int y = 22 + i * 10;
     if (i == splash_sel) u8g2.drawStr(2, y, ">");
     u8g2.drawStr(14, y, names[i]);
   }
   u8g2.drawStr(0, 62, "tap: change");
   u8g2.sendBuffer();
 }
 
 void display_whoami(const char* handle, const char* mac) {
   char buf[ROW_CHARS + 1], line[ROW_CHARS + 1];
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr(0, 10, "// whoami");
   u8g2.drawHLine(0, 13, 128);
   truncate(buf, (handle && handle[0]) ? handle : "(unset)", ROW_CHARS - 6);
   snprintf(line, sizeof(line), "user: %s", buf);
   u8g2.drawStr(0, 30, line);
   u8g2.drawStr(0, 46, "mac:");
   u8g2.drawStr(0, 61, mac);                       // "14:33:5C:xx:xx:xx" — 17 chars fits one line
   u8g2.sendBuffer();
 }
 
 void display_pet_popup(const char* face, const char* line1, const char* line2, uint16_t hold_ms) {
   u8g2.clearBuffer();
   u8g2.setFont(u8g2_font_9x18B_tf);
   u8g2.drawStr((128 - u8g2.getStrWidth(face)) / 2, line2 ? 30 : 36, face);  // lift the face for 2 lines
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr((128 - u8g2.getStrWidth(line1)) / 2, line2 ? 44 : 52, line1);
   if (line2) u8g2.drawStr((128 - u8g2.getStrWidth(line2)) / 2, 54, line2);
   u8g2.sendBuffer();
   delay(hold_ms);
   u8g2.setFont(ROW_FONT);
 }
 
 // Same face + 1–2 lines as display_pet_popup, but NON-BLOCKING (no delay). The caller
 // keeps it on screen and dismisses it (button / timeout) by redrawing the live view.
 void display_toast(const char* face, const char* line1, const char* line2) {
   u8g2.clearBuffer();
   u8g2.setFont(u8g2_font_9x18B_tf);
   u8g2.drawStr((128 - u8g2.getStrWidth(face)) / 2, line2 ? 30 : 36, face);
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr((128 - u8g2.getStrWidth(line1)) / 2, line2 ? 44 : 52, line1);
   if (line2) u8g2.drawStr((128 - u8g2.getStrWidth(line2)) / 2, 54, line2);
   u8g2.sendBuffer();                 // no delay — caller owns the frame's lifetime
 }
 
 void display_options_menu(int screen, int cursor, const OptView& v) {
   char r1[ROW_CHARS + 1], r2[ROW_CHARS + 1];
   const char* title;
   const char* rows[5];                             // Back first = the default row, every screen
   int nrows;
   if (screen == OPTM_USER) {
     title = "// user settings";
     // "Avatar: " is the same 8 chars as the old "Pet:    ", so it keeps the value column
     // aligned with Splash:/Bright:/Debug:/Global:/Shower:. At 8 + an 11-char name it is
     // exactly 19 chars = 114px at x=14 — the full width, with nothing to spare.
     snprintf(r1, sizeof(r1), "Avatar: %s", v.pet);
     snprintf(r2, sizeof(r2), "Finder View: %s", v.finder_mode);
     rows[0] = "Back"; rows[1] = r1; rows[2] = r2; rows[3] = "Reminders"; nrows = 4;
   } else if (screen == OPTM_DISPLAY) {
     title = "// display";
     snprintf(r1, sizeof(r1), "Splash: %s", v.splash);
     snprintf(r2, sizeof(r2), "Bright: %s", v.bright);
     rows[0] = "Back"; rows[1] = r1; rows[2] = r2; nrows = 3;
   } else if (screen == OPTM_DEVOPTS) {
     title = "// developer options";
     snprintf(r1, sizeof(r1), "Debug:  %s", v.test_state);
     rows[0] = "Back"; rows[1] = "Whoami"; rows[2] = r1;
     rows[3] = "Provisioning Mode"; rows[4] = "Factory Reset"; nrows = 5;   // 5 = the rows[] cap
   } else if (screen == OPTM_REMIND) {
     title = "// reminders";
     snprintf(r1, sizeof(r1), "Global: %s", v.remind_global);
     snprintf(r2, sizeof(r2), "Shower: %s", v.remind_shower);
     rows[0] = "Back"; rows[1] = r1; rows[2] = r2; nrows = 3;
   } else if (screen == OPTM_BADGE) {
     title = "// badge settings";
     snprintf(r1, sizeof(r1), "Stealth: %s", v.stealth);
     rows[0] = "Back"; rows[1] = "Display"; rows[2] = r1;
     rows[3] = "Developer Options"; rows[4] = "Power"; nrows = 5;    // 5 = the rows[] cap
   } else if (screen == OPTM_POWER) {
     title = "// power";
     rows[0] = "Back"; rows[1] = "Reboot"; rows[2] = "Deep sleep"; nrows = 3;
   } else {  // OPTM_ROOT
     title = "// options";
     rows[0] = "Back"; rows[1] = "User Settings"; rows[2] = "Badge Settings"; nrows = 3;
   }
   u8g2.clearBuffer();
   u8g2.setFont(ROW_FONT);
   u8g2.drawStr(0, 8, title);
   u8g2.drawHLine(0, 11, 128);
   int y0 = (nrows >= 5) ? 21 : (nrows == 4) ? 22 : 24;           // tighten as rows grow
   int dy = (nrows >= 5) ? 10 : (nrows == 4) ? 12 : 14;
   for (int i = 0; i < nrows; i++) {
     int y = y0 + i * dy;
     if (i == cursor) u8g2.drawStr(2, y, ">");
     u8g2.drawStr(14, y, rows[i]);
   }
   u8g2.sendBuffer();
 }
 
 #endif  // BADGE_DISPLAY_OLED