add a .clang-format file (#9154)

2026-01-17 23:37:44 +00:00 · 2026-01-03 21:19:24 +01:00
parent abab6ce815
commit 0d11331d18
771 changed files with 77752 additions and 83184 deletions
--- a/src/buzz/BuzzerFeedbackThread.cpp
+++ b/src/buzz/BuzzerFeedbackThread.cpp
@@ -5,60 +5,58 @@

 BuzzerFeedbackThread *buzzerFeedbackThread;

-BuzzerFeedbackThread::BuzzerFeedbackThread()
-{
-    if (inputBroker)
-        inputObserver.observe(inputBroker);
+BuzzerFeedbackThread::BuzzerFeedbackThread() {
+  if (inputBroker)
+    inputObserver.observe(inputBroker);
 }

-int BuzzerFeedbackThread::handleInputEvent(const InputEvent *event)
-{
-    // Only provide feedback if buzzer is enabled for notifications
-    if (config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DISABLED ||
-        config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_NOTIFICATIONS_ONLY ||
-        config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY) {
-        return 0; // Let other handlers process the event
+int BuzzerFeedbackThread::handleInputEvent(const InputEvent *event) {
+  // Only provide feedback if buzzer is enabled for notifications
+  if (config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DISABLED ||
+      config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_NOTIFICATIONS_ONLY ||
+      config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY) {
+    return 0; // Let other handlers process the event
+  }
+
+  // Handle different input events with appropriate buzzer feedback
+  switch (event->inputEvent) {
+  case INPUT_BROKER_USER_PRESS:
+  case INPUT_BROKER_ALT_PRESS:
+    playClick(); // Low delay feedback
+    break;
+
+  case INPUT_BROKER_SELECT:
+  case INPUT_BROKER_SELECT_LONG:
+    playBeep(); // Confirmation feedback
+    break;
+
+  case INPUT_BROKER_UP:
+  case INPUT_BROKER_UP_LONG:
+  case INPUT_BROKER_DOWN:
+  case INPUT_BROKER_DOWN_LONG:
+  case INPUT_BROKER_LEFT:
+  case INPUT_BROKER_RIGHT:
+    playChirp(); // Navigation feedback
+    break;
+
+  case INPUT_BROKER_CANCEL:
+  case INPUT_BROKER_BACK:
+    playBoop(); // Cancel/back feedback
+    break;
+
+  case INPUT_BROKER_SEND_PING:
+    playComboTune(); // Ping sent feedback
+    break;
+
+  default:
+    // For other events, check if it's a printable character
+    if (event->kbchar >= 32 && event->kbchar <= 126) {
+      // Typing feedback - very short boop
+      // Removing this for now, too chatty
+      // playChirp();
    }
+    break;
+  }

-    // Handle different input events with appropriate buzzer feedback
-    switch (event->inputEvent) {
-    case INPUT_BROKER_USER_PRESS:
-    case INPUT_BROKER_ALT_PRESS:
-        playClick(); // Low delay feedback
-        break;
-
-    case INPUT_BROKER_SELECT:
-    case INPUT_BROKER_SELECT_LONG:
-        playBeep(); // Confirmation feedback
-        break;
-
-    case INPUT_BROKER_UP:
-    case INPUT_BROKER_UP_LONG:
-    case INPUT_BROKER_DOWN:
-    case INPUT_BROKER_DOWN_LONG:
-    case INPUT_BROKER_LEFT:
-    case INPUT_BROKER_RIGHT:
-        playChirp(); // Navigation feedback
-        break;
-
-    case INPUT_BROKER_CANCEL:
-    case INPUT_BROKER_BACK:
-        playBoop(); // Cancel/back feedback
-        break;
-
-    case INPUT_BROKER_SEND_PING:
-        playComboTune(); // Ping sent feedback
-        break;
-
-    default:
-        // For other events, check if it's a printable character
-        if (event->kbchar >= 32 && event->kbchar <= 126) {
-            // Typing feedback - very short boop
-            // Removing this for now, too chatty
-            // playChirp();
-        }
-        break;
-    }
-
-    return 0; // Allow other handlers to process the event
+  return 0; // Allow other handlers to process the event
 }
--- a/src/buzz/BuzzerFeedbackThread.h
+++ b/src/buzz/BuzzerFeedbackThread.h
@@ -4,14 +4,13 @@
 #include "concurrency/OSThread.h"
 #include "input/InputBroker.h"

-class BuzzerFeedbackThread
-{
-    CallbackObserver<BuzzerFeedbackThread, const InputEvent *> inputObserver =
-        CallbackObserver<BuzzerFeedbackThread, const InputEvent *>(this, &BuzzerFeedbackThread::handleInputEvent);
+class BuzzerFeedbackThread {
+  CallbackObserver<BuzzerFeedbackThread, const InputEvent *> inputObserver =
+      CallbackObserver<BuzzerFeedbackThread, const InputEvent *>(this, &BuzzerFeedbackThread::handleInputEvent);

-  public:
-    BuzzerFeedbackThread();
-    int handleInputEvent(const InputEvent *event);
+public:
+  BuzzerFeedbackThread();
+  int handleInputEvent(const InputEvent *event);
 };

 extern BuzzerFeedbackThread *buzzerFeedbackThread;
--- a/src/buzz/buzz.cpp
+++ b/src/buzz/buzz.cpp
@@ -11,8 +11,8 @@ extern "C" void delay(uint32_t dwMs);
 #endif

 struct ToneDuration {
-    int frequency_khz;
-    int duration_ms;
+  int frequency_khz;
+  int duration_ms;
 };

 // Some common frequencies.
@@ -42,105 +42,92 @@ const int DURATION_1_2 = 500;  // 1/2 note
 const int DURATION_3_4 = 750;  // 3/4 note
 const int DURATION_1_1 = 1000; // 1/1 note

-void playTones(const ToneDuration *tone_durations, int size)
-{
-    if (config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DISABLED ||
-        config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_NOTIFICATIONS_ONLY) {
-        // Buzzer is disabled or not set to system tones
-        return;
-    }
+void playTones(const ToneDuration *tone_durations, int size) {
+  if (config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DISABLED ||
+      config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_NOTIFICATIONS_ONLY) {
+    // Buzzer is disabled or not set to system tones
+    return;
+  }
 #ifdef PIN_BUZZER
-    if (!config.device.buzzer_gpio)
-        config.device.buzzer_gpio = PIN_BUZZER;
+  if (!config.device.buzzer_gpio)
+    config.device.buzzer_gpio = PIN_BUZZER;
 #endif
-    if (config.device.buzzer_gpio) {
-        for (int i = 0; i < size; i++) {
-            const auto &tone_duration = tone_durations[i];
-            tone(config.device.buzzer_gpio, tone_duration.frequency_khz, tone_duration.duration_ms);
-            // to distinguish the notes, set a minimum time between them.
-            delay(1.3 * tone_duration.duration_ms);
-        }
+  if (config.device.buzzer_gpio) {
+    for (int i = 0; i < size; i++) {
+      const auto &tone_duration = tone_durations[i];
+      tone(config.device.buzzer_gpio, tone_duration.frequency_khz, tone_duration.duration_ms);
+      // to distinguish the notes, set a minimum time between them.
+      delay(1.3 * tone_duration.duration_ms);
    }
+  }
 }

-void playBeep()
-{
-    ToneDuration melody[] = {{NOTE_B3, DURATION_1_8}};
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playBeep() {
+  ToneDuration melody[] = {{NOTE_B3, DURATION_1_8}};
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }

-void playLongBeep()
-{
-    ToneDuration melody[] = {{NOTE_B3, DURATION_1_1}};
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playLongBeep() {
+  ToneDuration melody[] = {{NOTE_B3, DURATION_1_1}};
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }

-void playGPSEnableBeep()
-{
+void playGPSEnableBeep() {
 #if defined(R1_NEO) || defined(MUZI_BASE)
-    ToneDuration melody[] = {
-        {NOTE_F5, DURATION_1_2}, {NOTE_G6, DURATION_1_8}, {NOTE_E7, DURATION_1_4}, {NOTE_SILENT, DURATION_1_2}};
+  ToneDuration melody[] = {{NOTE_F5, DURATION_1_2}, {NOTE_G6, DURATION_1_8}, {NOTE_E7, DURATION_1_4}, {NOTE_SILENT, DURATION_1_2}};
 #else
-    ToneDuration melody[] = {{NOTE_C3, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}, {NOTE_CS4, DURATION_1_4}};
+  ToneDuration melody[] = {{NOTE_C3, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}, {NOTE_CS4, DURATION_1_4}};
 #endif
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }

-void playGPSDisableBeep()
-{
+void playGPSDisableBeep() {
 #if defined(R1_NEO) || defined(MUZI_BASE)
-    ToneDuration melody[] = {{NOTE_B4, DURATION_1_16}, {NOTE_B4, DURATION_1_16},   {NOTE_SILENT, DURATION_1_8},
-                             {NOTE_F3, DURATION_1_16}, {NOTE_F3, DURATION_1_16},   {NOTE_SILENT, DURATION_1_8},
-                             {NOTE_C3, DURATION_1_1},  {NOTE_SILENT, DURATION_1_1}};
+  ToneDuration melody[] = {{NOTE_B4, DURATION_1_16}, {NOTE_B4, DURATION_1_16},    {NOTE_SILENT, DURATION_1_8}, {NOTE_F3, DURATION_1_16},
+                           {NOTE_F3, DURATION_1_16}, {NOTE_SILENT, DURATION_1_8}, {NOTE_C3, DURATION_1_1},     {NOTE_SILENT, DURATION_1_1}};
 #else
-    ToneDuration melody[] = {{NOTE_CS4, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}, {NOTE_C3, DURATION_1_4}};
+  ToneDuration melody[] = {{NOTE_CS4, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}, {NOTE_C3, DURATION_1_4}};
 #endif
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }

-void playStartMelody()
-{
-    ToneDuration melody[] = {{NOTE_FS3, DURATION_1_8}, {NOTE_AS3, DURATION_1_8}, {NOTE_CS4, DURATION_1_4}};
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playStartMelody() {
+  ToneDuration melody[] = {{NOTE_FS3, DURATION_1_8}, {NOTE_AS3, DURATION_1_8}, {NOTE_CS4, DURATION_1_4}};
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }

-void playShutdownMelody()
-{
-    ToneDuration melody[] = {{NOTE_CS4, DURATION_1_8}, {NOTE_AS3, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}};
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playShutdownMelody() {
+  ToneDuration melody[] = {{NOTE_CS4, DURATION_1_8}, {NOTE_AS3, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}};
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }

-void playChirp()
-{
-    // A short, friendly "chirp" sound for key presses
-    ToneDuration melody[] = {{NOTE_AS3, 20}}; // Short AS3 note
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playChirp() {
+  // A short, friendly "chirp" sound for key presses
+  ToneDuration melody[] = {{NOTE_AS3, 20}}; // Short AS3 note
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }

-void playClick()
-{
-    // A very short "click" sound with minimum delay; ideal for rotary encoder events
-    ToneDuration melody[] = {{NOTE_AS3, 1}}; // Very Short AS3
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playClick() {
+  // A very short "click" sound with minimum delay; ideal for rotary encoder events
+  ToneDuration melody[] = {{NOTE_AS3, 1}}; // Very Short AS3
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }

-void playBoop()
-{
-    // A short, friendly "boop" sound for button presses
-    ToneDuration melody[] = {{NOTE_A3, 50}}; // Very short A3 note
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playBoop() {
+  // A short, friendly "boop" sound for button presses
+  ToneDuration melody[] = {{NOTE_A3, 50}}; // Very short A3 note
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }

-void playLongPressLeadUp()
-{
-    // An ascending lead-up sequence for long press - builds anticipation
-    ToneDuration melody[] = {
-        {NOTE_C3, 100}, // Start low
-        {NOTE_E3, 100}, // Step up
-        {NOTE_G3, 100}, // Keep climbing
-        {NOTE_B3, 150}  // Peak with longer note for emphasis
-    };
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playLongPressLeadUp() {
+  // An ascending lead-up sequence for long press - builds anticipation
+  ToneDuration melody[] = {
+      {NOTE_C3, 100}, // Start low
+      {NOTE_E3, 100}, // Step up
+      {NOTE_G3, 100}, // Keep climbing
+      {NOTE_B3, 150}  // Peak with longer note for emphasis
+  };
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }

 // Static state for progressive lead-up notes
@@ -153,39 +140,34 @@ static const ToneDuration leadUpNotes[] = {
 };
 static const int leadUpNotesCount = sizeof(leadUpNotes) / sizeof(ToneDuration);

-bool playNextLeadUpNote()
-{
-    if (leadUpNoteIndex >= leadUpNotesCount) {
-        return false; // All notes have been played
-    }
+bool playNextLeadUpNote() {
+  if (leadUpNoteIndex >= leadUpNotesCount) {
+    return false; // All notes have been played
+  }

-    // Use playTones to handle buzzer logic consistently
-    const auto &note = leadUpNotes[leadUpNoteIndex];
-    playTones(&note, 1); // Play single note using existing playTones function
+  // Use playTones to handle buzzer logic consistently
+  const auto &note = leadUpNotes[leadUpNoteIndex];
+  playTones(&note, 1); // Play single note using existing playTones function

-    leadUpNoteIndex++;
+  leadUpNoteIndex++;

-    if (leadUpNoteIndex >= leadUpNotesCount) {
-        return false; // this was the final note
-    }
-    return true; // Note was played (playTones handles buzzer availability internally)
+  if (leadUpNoteIndex >= leadUpNotesCount) {
+    return false; // this was the final note
+  }
+  return true; // Note was played (playTones handles buzzer availability internally)
 }

-void resetLeadUpSequence()
-{
-    leadUpNoteIndex = 0;
-}
+void resetLeadUpSequence() { leadUpNoteIndex = 0; }

-void playComboTune()
-{
-    // Quick high-pitched notes with trills
-    ToneDuration melody[] = {
-        {NOTE_G3, 80},  // Quick chirp
-        {NOTE_B3, 60},  // Higher chirp
-        {NOTE_CS4, 80}, // Even higher
-        {NOTE_G3, 60},  // Quick trill down
-        {NOTE_CS4, 60}, // Quick trill up
-        {NOTE_B3, 120}  // Ending chirp
-    };
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playComboTune() {
+  // Quick high-pitched notes with trills
+  ToneDuration melody[] = {
+      {NOTE_G3, 80},  // Quick chirp
+      {NOTE_B3, 60},  // Higher chirp
+      {NOTE_CS4, 80}, // Even higher
+      {NOTE_G3, 60},  // Quick trill down
+      {NOTE_CS4, 60}, // Quick trill up
+      {NOTE_B3, 120}  // Ending chirp
+  };
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }