Indicator Timeout Buzzer

#include <Arduino.h>
#include <Preferences.h>
#include "driver/twai.h"

// Verified against the current CAN Pal and piezo wiring.
constexpr int CAN_RX_PIN = 21;
constexpr int CAN_TX_PIN = 22;
constexpr int BUZZER_PIN = 25;
constexpr uint32_t CAN_BITRATE = 500000;
constexpr uint32_t LEARN_TIMEOUT_MS = 60000;
constexpr uint32_t BLINK_MIN_MS = 250;
constexpr uint32_t BLINK_MAX_MS = 1500;
constexpr uint32_t SIGNAL_GONE_MS = 2000;
constexpr uint32_t REMINDER_DELAY_MS = 20000;

struct LearnedSignal {
  uint32_t magic;
  uint32_t identifier;
  uint8_t byteIndex;
  uint8_t bitMask;
};

struct Candidate {
  bool used;
  uint32_t identifier;
  uint8_t byteIndex;
  uint8_t bitMask;
  bool lastState;
  uint32_t lastToggleMs;
  uint8_t score;
};

constexpr uint32_t SETTINGS_MAGIC = 0x5349474CUL;
constexpr size_t MAX_CANDIDATES = 48;
Preferences preferences;
LearnedSignal learned = {};
Candidate candidates[MAX_CANDIDATES] = {};
bool learningMode = false;
bool signalBitKnown = false;
bool lastLearnedBit = false;
uint32_t firstBlinkMs = 0;
uint32_t lastBlinkMs = 0;
uint32_t buzzerPhaseMs = 0;
bool buzzerOn = false;

void stopBuzzer() {
  ledcWriteTone(BUZZER_PIN, 0);
  buzzerOn = false;
}

void updateBuzzer(uint32_t now) {
  bool signalStillBlinking = firstBlinkMs != 0 && (now - lastBlinkMs) <= SIGNAL_GONE_MS;
  if (!signalStillBlinking) {
    firstBlinkMs = 0;
    stopBuzzer();
    return;
  }

  if ((now - firstBlinkMs) < REMINDER_DELAY_MS) {
    stopBuzzer();
    return;
  }

  // A short chirp once per second is noticeable without being a continuous distraction.
  uint32_t phase = now % 1000;
  bool shouldSound = phase < 180;
  if (shouldSound != buzzerOn) {
    ledcWriteTone(BUZZER_PIN, shouldSound ? 2600 : 0);
    buzzerOn = shouldSound;
  }
}

bool startCan() {
  twai_general_config_t general = TWAI_GENERAL_CONFIG_DEFAULT((gpio_num_t)CAN_TX_PIN, (gpio_num_t)CAN_RX_PIN, TWAI_MODE_LISTEN_ONLY);
  twai_timing_config_t timing = TWAI_TIMING_CONFIG_500KBITS();
  twai_filter_config_t filter = TWAI_FILTER_CONFIG_ACCEPT_ALL();
  if (twai_driver_install(&general, &timing, &filter) != ESP_OK) {
    return false;
  }
  return twai_start() == ESP_OK;
}

Candidate *findCandidate(uint32_t identifier, uint8_t byteIndex, uint8_t bitMask, bool state) {
  for (size_t i = 0; i < MAX_CANDIDATES; ++i) {
    if (candidates[i].used && candidates[i].identifier == identifier &&
        candidates[i].byteIndex == byteIndex && candidates[i].bitMask == bitMask) {
      return &candidates[i];
    }
  }
  for (size_t i = 0; i < MAX_CANDIDATES; ++i) {
    if (!candidates[i].used) {
      candidates[i] = {true, identifier, byteIndex, bitMask, state, 0, 0};
      return &candidates[i];
    }
  }
  return nullptr;
}

void saveLearned(Candidate &candidate) {
  learned.magic = SETTINGS_MAGIC;
  learned.identifier = candidate.identifier;
  learned.byteIndex = candidate.byteIndex;
  learned.bitMask = candidate.bitMask;
  preferences.putBytes("signal", &learned, sizeof(learned));
  learningMode = false;
  signalBitKnown = false;
  Serial.printf("Learned CAN ID 0x%lX, byte %u, mask 0x%02X. Restarting monitor.\n", (unsigned long)learned.identifier, learned.byteIndex, learned.bitMask);
  delay(300);
  ESP.restart();
}

void processLearningFrame(const twai_message_t &message, uint32_t now) {
  if (message.rtr || message.data_length_code == 0) return;
  for (uint8_t byteIndex = 0; byteIndex < message.data_length_code; ++byteIndex) {
    for (uint8_t bit = 0; bit < 8; ++bit) {
      uint8_t mask = (uint8_t)(1U << bit);
      bool state = (message.data[byteIndex] & mask) != 0;
      Candidate *candidate = findCandidate(message.identifier, byteIndex, mask, state);
      if (candidate == nullptr || state == candidate->lastState) continue;

      uint32_t interval = now - candidate->lastToggleMs;
      candidate->lastState = state;
      candidate->lastToggleMs = now;
      if (interval >= BLINK_MIN_MS && interval <= BLINK_MAX_MS) {
        candidate->score++;
      } else {
        candidate->score = 1;
      }
      if (candidate->score >= 6) {
        saveLearned(*candidate);
      }
    }
  }
}

void processMonitorFrame(const twai_message_t &message, uint32_t now) {
  if (message.rtr || message.identifier != learned.identifier || learned.byteIndex >= message.data_length_code) return;
  bool bit = (message.data[learned.byteIndex] & learned.bitMask) != 0;
  if (!signalBitKnown) {
    lastLearnedBit = bit;
    signalBitKnown = true;
    return;
  }
  if (bit != lastLearnedBit) {
    lastLearnedBit = bit;
    lastBlinkMs = now;
    if (firstBlinkMs == 0) {
      firstBlinkMs = now;
      Serial.println("Turn-signal blink detected; 20-second reminder timer started.");
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(BOOT_PIN, INPUT_PULLUP);
  pinMode(BUZZER_PIN, OUTPUT);
  ledcAttach(BUZZER_PIN, 2600, 8);
  stopBuzzer();

  preferences.begin("turnrem", false);
  size_t count = preferences.getBytesLength("signal");
  if (count == sizeof(learned)) preferences.getBytes("signal", &learned, sizeof(learned));

  // Hold the ESP32 BOOT button while powering it to replace the saved signal selection.
  learningMode = digitalRead(BOOT_PIN) == LOW || learned.magic != SETTINGS_MAGIC;
  if (learningMode) {
    memset(candidates, 0, sizeof(candidates));
    Serial.println("LEARNING: For the next 60 seconds, operate only one turn signal. Do not press other motorcycle controls.");
  } else {
    Serial.printf("Monitoring saved CAN ID 0x%lX. Hold BOOT during power-up to learn again.\n", (unsigned long)learned.identifier);
  }

  if (!startCan()) {
    Serial.println("CAN driver failed to start. Check CAN Pal wiring and use an ESP32 DevKit v1.");
  }
}

void loop() {
  twai_message_t message;
  uint32_t now = millis();
  while (twai_receive(&message, pdMS_TO_TICKS(5)) == ESP_OK) {
    if (learningMode) processLearningFrame(message, now);
    else processMonitorFrame(message, now);
    now = millis();
  }

  if (learningMode && now >= LEARN_TIMEOUT_MS) {
    Serial.println("No repeating indicator bit was learned. Restart while holding BOOT and try again with only a turn signal operating.");
    delay(1000);
    ESP.restart();
  }
  if (!learningMode) updateBuzzer(now);
  delay(1);
}