Battle Pass Spin Analyzer

#include <Arduino.h>
#include <Wire.h>
#include <Preferences.h>
#include <NimBLEDevice.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH110X.h>

static const char* BATTLE_PASS_SERVICE_UUID = "55C40000-F8EB-11EC-B939-0242AC120002";
constexpr int OLED_SDA = 8;
constexpr int OLED_SCL = 9;
constexpr int BUTTON_NEXT = 1;
constexpr int BUTTON_SAVE = 2;
constexpr uint8_t OLED_ADDRESS = 0x3C;
constexpr uint8_t GRAPH_POINTS = 30;
constexpr uint8_t HISTORY_LIMIT = 8;

Adafruit_SH1106G display(128, 64, &Wire, -1);
Preferences preferences;
NimBLEClient* client = nullptr;
volatile bool packetArrived = false;
char newestPacket[49] = "WAITING";
uint16_t packetBytes = 0;
uint32_t packetCount = 0;
uint8_t packetGraph[GRAPH_POINTS] = {};
uint8_t graphHead = 0;
String history[HISTORY_LIMIT];
uint8_t historyCount = 0;
bool connected = false;
bool scanning = false;
bool displayDirty = true;
uint8_t page = 0;
uint32_t lastButton = 0;
uint32_t timerStartedAt = 0;

String hexText(const uint8_t* data, size_t length) {
  String text;
  for (size_t i = 0; i < length && i < 12; ++i) {
    if (data[i] < 16) text += '0';
    text += String(data[i], HEX);
  }
  if (length > 12) text += "+";
  text.toUpperCase();
  return text;
}

void saveHistory() {
  String joined;
  for (uint8_t i = 0; i < historyCount; ++i) {
    if (i) joined += '\n';
    joined += history[i];
  }
  preferences.putString("history", joined);
}

void addHistory(const String& item) {
  if (historyCount < HISTORY_LIMIT) history[historyCount++] = item;
  else {
    for (uint8_t i = 1; i < HISTORY_LIMIT; ++i) history[i - 1] = history[i];
    history[HISTORY_LIMIT - 1] = item;
  }
  saveHistory();
}

void loadHistory() {
  String joined = preferences.getString("history", "");
  while (joined.length() && historyCount < HISTORY_LIMIT) {
    int end = joined.indexOf('\n');
    if (end < 0) { history[historyCount++] = joined; break; }
    history[historyCount++] = joined.substring(0, end);
    joined.remove(0, end + 1);
  }
}

void notifyCallback(NimBLERemoteCharacteristic* characteristic, uint8_t* data, size_t length, bool isNotify) {
  (void)characteristic;
  (void)isNotify;
  packetBytes = length;
  packetCount++;
  graphHead = (graphHead + 1) % GRAPH_POINTS;
  packetGraph[graphHead] = min((size_t)48, length * 3);
  String packet = hexText(data, length);
  packet.toCharArray(newestPacket, sizeof(newestPacket));
  packetArrived = true;
}

class ClientCallbacks : public NimBLEClientCallbacks {
  void onConnect(NimBLEClient* pClient) override {
    (void)pClient;
    connected = true;
    displayDirty = true;
  }
  void onDisconnect(NimBLEClient* pClient, int reason) override {
    (void)pClient;
    (void)reason;
    connected = false;
    scanning = false;
    strcpy(newestPacket, "DISCONNECTED");
    displayDirty = true;
  }
};
ClientCallbacks clientCallbacks;

bool subscribeAllNotifications() {
  const std::vector<NimBLERemoteService*>& services = client->getServices(true);
  bool subscribed = false;
  for (NimBLERemoteService* service : services) {
    const std::vector<NimBLERemoteCharacteristic*>& characteristics = service->getCharacteristics(true);
    for (NimBLERemoteCharacteristic* characteristic : characteristics) {
      if (characteristic->canNotify() || characteristic->canIndicate()) {
        bool indication = characteristic->canIndicate() && !characteristic->canNotify();
        if (characteristic->subscribe(indication, notifyCallback)) subscribed = true;
      }
      if (characteristic->canRead()) {
        std::string value = characteristic->readValue();
        if (!value.empty()) notifyCallback(characteristic, reinterpret_cast<uint8_t*>(value.data()), value.length(), false);
      }
    }
  }
  return subscribed;
}

void connectToPass(NimBLEAdvertisedDevice* device) {
  if (client && client->isConnected()) return;
  if (!client) {
    client = NimBLEDevice::createClient();
    client->setClientCallbacks(&clientCallbacks, false);
    client->setConnectTimeout(5);
  }
  if (client->connect(device)) {
    connected = true;
    if (!subscribeAllNotifications()) strcpy(newestPacket, "NO NOTIFY");
  } else strcpy(newestPacket, "CONNECT FAIL");
  displayDirty = true;
}

class ScanCallbacks : public NimBLEScanCallbacks {
  void onResult(const NimBLEAdvertisedDevice* device) override {
    NimBLEUUID wanted(BATTLE_PASS_SERVICE_UUID);
    if (device->isAdvertisingService(wanted) && !connected) {
      NimBLEDevice::getScan()->stop();
      scanning = false;
      connectToPass(const_cast<NimBLEAdvertisedDevice*>(device));
    }
  }
};
ScanCallbacks scanCallbacks;

void startScan() {
  if (connected || scanning) return;
  NimBLEScan* scan = NimBLEDevice::getScan();
  scan->setScanCallbacks(&scanCallbacks, false);
  scan->setInterval(45);
  scan->setWindow(15);
  scan->setActiveScan(true);
  scan->start(0, false, true);
  scanning = true;
  displayDirty = true;
}

void printLine(uint8_t row, const String& text) {
  display.setCursor(0, row * 8);
  display.print(text.substring(0, 21));
}

String elapsedText() {
  uint32_t seconds = (millis() - timerStartedAt) / 1000;
  char text[10];
  snprintf(text, sizeof(text), "%02lu:%02lu", (unsigned long)(seconds / 60), (unsigned long)(seconds % 60));
  return String(text);
}

void drawLive() {
  display.clearDisplay();
  printLine(0, connected ? "LIVE  BX09 LINKED" : "LIVE  SCANNING BX09");
  printLine(1, "SP: --   TIME " + elapsedText());
  printLine(2, "RAW PKT:" + String(packetCount) + " B:" + String(packetBytes));
  printLine(3, String(newestPacket));
  display.drawFastHLine(0, 31, 128, SH110X_WHITE);
  for (uint8_t i = 1; i < GRAPH_POINTS; ++i) {
    uint8_t a = (graphHead + i) % GRAPH_POINTS;
    uint8_t b = (graphHead + i + 1) % GRAPH_POINTS;
    display.drawLine((i - 1) * 4, 63 - packetGraph[a], i * 4, 63 - packetGraph[b], SH110X_WHITE);
  }
  display.display();
}

void drawMetrics() {
  display.clearDisplay();
  printLine(0, "SHOT METRICS");
  printLine(1, "HIGH RPM: --");
  printLine(2, "LOW  RPM: --");
  printLine(3, "AVG  RPM: --");
  printLine(4, "STABILITY: --");
  printLine(5, "SHOTS: --");
  printLine(7, "WAITING FOR BX09 DATA");
  display.display();
}

void drawHistory() {
  display.clearDisplay();
  printLine(0, "SAVED RAW PACKETS");
  if (!historyCount) printLine(2, "NO SAVES YET");
  else {
    uint8_t first = historyCount > 7 ? historyCount - 7 : 0;
    for (uint8_t i = first; i < historyCount; ++i) printLine(i - first + 1, history[i]);
  }
  display.display();
}

void redraw() {
  if (page == 0) drawLive();
  else if (page == 1) drawMetrics();
  else drawHistory();
  displayDirty = false;
}

void handleButtons() {
  if (millis() - lastButton < 220) return;
  if (digitalRead(BUTTON_NEXT) == LOW) {
    page = (page + 1) % 3;
    lastButton = millis();
    displayDirty = true;
  } else if (digitalRead(BUTTON_SAVE) == LOW) {
    addHistory(String(packetCount) + ":" + String(newestPacket));
    lastButton = millis();
    displayDirty = true;
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(BUTTON_NEXT, INPUT_PULLUP);
  pinMode(BUTTON_SAVE, INPUT_PULLUP);
  Wire.begin(OLED_SDA, OLED_SCL);
  if (!display.begin(OLED_ADDRESS, true)) while (true) delay(1000);
  display.setTextSize(1);
  display.setTextColor(SH110X_WHITE);
  preferences.begin("bx09", false);
  loadHistory();
  NimBLEDevice::init("BX09-Reader");
  timerStartedAt = millis();
  startScan();
  redraw();
}

void loop() {
  handleButtons();
  if (!connected && !scanning) startScan();
  if (packetArrived) {
    packetArrived = false;
    displayDirty = true;
  }
  if (page == 0 && millis() % 1000 < 10) displayDirty = true;
  if (displayDirty) redraw();
  delay(10);
}