Unify buzz methods as MarlinUI::buzz (#14803)

Marlin/src/Marlin.cpp

   #include "feature/host_actions.h"
 #endif
 
-#if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER)
+#if USE_BEEPER
   #include "libs/buzzer.h"
 #endif
 
     print_job_timer.tick();
   #endif
 
-  #if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER) && DISABLED(PCA9632_BUZZER)
+  #if USE_BEEPER
     buzzer.tick();
   #endif
 

Marlin/src/feature/leds/pca9632.cpp

 }
 
 #if ENABLED(PCA9632_BUZZER)
-  void pca9632_buzz(uint16_t const f, uint16_t d) {
-    UNUSED(f); UNUSED(d);
+
+  void pca9632_buzz(const long duration, const uint16_t freq) {
+    UNUSED(duration); UNUSED(freq);
     uint8_t data[] = PCA9632_BUZZER_DATA;
     Wire.beginTransmission(I2C_ADDRESS(PCA9632_ADDRESS));
     Wire.write(data, sizeof(data));
     Wire.endTransmission();
   }
-#endif
+
+#endif // PCA9632_BUZZER
 
 #endif // PCA9632

Marlin/src/feature/leds/pca9632.h

 void pca9632_set_led_color(const LEDColor &color);
 
 #if ENABLED(PCA9632_BUZZER)
-  void pca9632_buzz(uint16_t const, uint16_t);
+  #include <stdint.h>
+  void pca9632_buzz(const long, const uint16_t);
 #endif

Marlin/src/inc/Conditionals_post.h

 #define HAS_KILL        (PIN_EXISTS(KILL))
 #define HAS_SUICIDE     (PIN_EXISTS(SUICIDE))
 #define HAS_PHOTOGRAPH  (PIN_EXISTS(PHOTOGRAPH))
-#define HAS_BUZZER      (PIN_EXISTS(BEEPER) || ENABLED(LCD_USE_I2C_BUZZER) || ENABLED(PCA9632_BUZZER))
+#define HAS_BUZZER      (PIN_EXISTS(BEEPER) || EITHER(LCD_USE_I2C_BUZZER, PCA9632_BUZZER))
+#define USE_BEEPER      (HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER, PCA9632_BUZZER))
 #define HAS_CASE_LIGHT  (PIN_EXISTS(CASE_LIGHT) && ENABLED(CASE_LIGHT_ENABLE))
 
 // Digital control
   #ifndef LCD_FEEDBACK_FREQUENCY_DURATION_MS
     #define LCD_FEEDBACK_FREQUENCY_DURATION_MS 100
   #endif
-#else
+#elif HAS_BUZZER
   #ifndef LCD_FEEDBACK_FREQUENCY_HZ
     #define LCD_FEEDBACK_FREQUENCY_HZ 5000
   #endif

Marlin/src/lcd/HD44780/ultralcd_HD44780.cpp

   lcd.clear();
 }
 
+bool MarlinUI::detected() {
+  return true
+    #if EITHER(LCD_I2C_TYPE_MCP23017, LCD_I2C_TYPE_MCP23008) && defined(DETECT_DEVICE)
+      && lcd.LcdDetected() == 1
+    #endif
+  ;
+}
+
+#if HAS_SLOW_BUTTONS
+  uint8_t MarlinUI::read_slow_buttons() {
+    #if ENABLED(LCD_I2C_TYPE_MCP23017)
+      // Reading these buttons this is likely to be too slow to call inside interrupt context
+      // so they are called during normal lcd_update
+      uint8_t slow_bits = lcd.readButtons()
+        #if !BUTTON_EXISTS(ENC)
+          << B_I2C_BTN_OFFSET
+        #endif
+      ;
+      #if ENABLED(LCD_I2C_VIKI)
+        if ((slow_bits & (B_MI | B_RI)) && PENDING(millis(), next_button_update_ms)) // LCD clicked
+          slow_bits &= ~(B_MI | B_RI); // Disable LCD clicked buttons if screen is updated
+      #endif // LCD_I2C_VIKI
+      return slow_bits;
+    #endif // LCD_I2C_TYPE_MCP23017
+  }
+#endif
+
 void MarlinUI::clear_lcd() { lcd.clear(); }
 
 #if ENABLED(SHOW_BOOTSCREEN)
 
   #if ENABLED(LCD_HAS_STATUS_INDICATORS)
 
-    static void MarlinUI::update_indicators() {
+    void MarlinUI::update_indicators() {
       // Set the LEDS - referred to as backlights by the LiquidTWI2 library
       static uint8_t ledsprev = 0;
       uint8_t leds = 0;

Marlin/src/lcd/dogm/ultralcd_DOGM.cpp

   }
 }
 
+bool MarlinUI::detected() { return true; }
+
 #if ENABLED(SHOW_BOOTSCREEN)
 
   #if ENABLED(SHOW_CUSTOM_BOOTSCREEN)

Marlin/src/lcd/ultralcd.cpp

   uint8_t MarlinUI::progress_bar_percent; // = 0
 #endif
 
+#if HAS_BUZZER
+  #include "../libs/buzzer.h"
+  void MarlinUI::buzz(const long duration, const uint16_t freq) {
+    #if ENABLED(LCD_USE_I2C_BUZZER)
+      lcd.buzz(duration, freq);
+    #elif ENABLED(PCA9632_BUZZER)
+      pca9632_buzz(const long duration, const uint16_t freq) {
+    #elif USE_BEEPER
+      buzzer.tone(duration, freq);
+    #endif
+  }
+#endif
+
 #if HAS_SPI_LCD
 
 #if HAS_GRAPHICAL_LCD
   #include "../feature/bedlevel/bedlevel.h"
 #endif
 
-#if HAS_BUZZER
-  #include "../libs/buzzer.h"
-#endif
-
 #if HAS_TRINAMIC
   #include "../feature/tmc_util.h"
 #endif
           const millis_t ms = millis();
         #endif
         if (ELAPSED(ms, next_beep)) {
-          BUZZ(FEEDRATE_CHANGE_BEEP_DURATION, FEEDRATE_CHANGE_BEEP_FREQUENCY);
+          buzz(FEEDRATE_CHANGE_BEEP_DURATION, FEEDRATE_CHANGE_BEEP_FREQUENCY);
           next_beep = ms + 500UL;
         }
       #endif
   #if HAS_BUZZER
     // Buzz and wait. Is the delay needed for buttons to settle?
     buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
-  #endif
-
-  #if HAS_LCD_MENU
-    #if ENABLED(LCD_USE_I2C_BUZZER)
-      delay(10);
-    #elif PIN_EXISTS(BEEPER)
-      for (int8_t i = 5; i--;) { buzzer.tick(); delay(2); }
+    #if HAS_LCD_MENU
+      #if USE_BEEPER
+        for (int8_t i = 5; i--;) { buzzer.tick(); delay(2); }
+      #else
+        delay(10);
+      #endif
     #endif
   #endif
 }
 
 LCDViewAction MarlinUI::lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW;
 
-bool MarlinUI::detected() {
-  return
-    #if EITHER(LCD_I2C_TYPE_MCP23017, LCD_I2C_TYPE_MCP23008) && defined(DETECT_DEVICE)
-      lcd.LcdDetected() == 1
-    #else
-      true
-    #endif
-  ;
-}
-
 void MarlinUI::update() {
 
   static uint16_t max_display_update_time = 0;
     #endif // HAS_ENCODER_WHEEL
   }
 
-  #if HAS_SLOW_BUTTONS
-
-    uint8_t MarlinUI::read_slow_buttons() {
-      #if ENABLED(LCD_I2C_TYPE_MCP23017)
-        // Reading these buttons this is likely to be too slow to call inside interrupt context
-        // so they are called during normal lcd_update
-        uint8_t slow_bits = lcd.readButtons() << B_I2C_BTN_OFFSET;
-        #if ENABLED(LCD_I2C_VIKI)
-          if ((slow_bits & (B_MI | B_RI)) && PENDING(millis(), next_button_update_ms)) // LCD clicked
-            slow_bits &= ~(B_MI | B_RI); // Disable LCD clicked buttons if screen is updated
-        #endif // LCD_I2C_VIKI
-        return slow_bits;
-      #endif // LCD_I2C_TYPE_MCP23017
-    }
-
-  #endif
-
 #endif // HAS_ENCODER_ACTION
 
 #endif // HAS_SPI_LCD

Marlin/src/lcd/ultralcd.h

   }
 
   #if HAS_BUZZER
-    static inline void buzz(const long duration, const uint16_t freq) {
-      #if ENABLED(LCD_USE_I2C_BUZZER)
-        lcd.buzz(duration, freq);
-      #elif PIN_EXISTS(BEEPER)
-        buzzer.tone(duration, freq);
-      #elif ENABLED(PCA9632_BUZZER)
-        pca9632_buzz(duration, freq);
-      #endif
-    }
+    static void buzz(const long duration, const uint16_t freq);
+  #endif
+
+  #if ENABLED(LCD_HAS_STATUS_INDICATORS)
+    static void update_indicators();
   #endif
 
   // LCD implementations

Marlin/src/libs/buzzer.cpp

 
 #include "../inc/MarlinConfig.h"
 
-#if DISABLED(LCD_USE_I2C_BUZZER) && PIN_EXISTS(BEEPER)
+#if USE_BEEPER
 
 #include "buzzer.h"
 #include "../module/temperature.h"
   else if (ELAPSED(now, state.endtime)) reset();
 }
 
-#endif // !LCD_USE_I2C_BUZZER && BEEPER
+#endif // USE_BEEPER

Marlin/src/libs/buzzer.h

 
 #include "../inc/MarlinConfig.h"
 
-#if ENABLED(LCD_USE_I2C_BUZZER)
-
-  #define BUZZ(d,f) ui.buzz(d,f)
-
-#elif ENABLED(PCA9632_BUZZER)
-
-  #include "../feature/leds/pca9632.h"
-  #define BUZZ(d, f) pca9632_buzz(d,f)
-
-#elif PIN_EXISTS(BEEPER)
+#if USE_BEEPER
 
   #include "circularqueue.h"
 
 
   // Provide a buzzer instance
   extern Buzzer buzzer;
+
+  // Buzz directly via the BEEPER pin tone queue
   #define BUZZ(d,f) buzzer.tone(d, f)
 
-#else // No buzz capability
+#elif HAS_BUZZER
+
+  // Buzz indirectly via the MarlinUI instance
+  #define BUZZ(d,f) ui.buzz(d,f)
+
+#else
 
+  // No buzz capability
   #define BUZZ(d,f) NOOP
 
 #endif

Marlin/src/module/printcounter.cpp

     #endif
     #if HAS_BUZZER && SERVICE_WARNING_BUZZES > 0
       if (doBuzz) for (int i = 0; i < SERVICE_WARNING_BUZZES; i++) BUZZ(200, 404);
+    #else
+      UNUSED(doBuzz);
     #endif
   #endif // HAS_SERVICE_INTERVALS
 }

Marlin/src/module/temperature.cpp

   #include "tool_change.h"
 #endif
 
-#if HAS_BUZZER && PIN_EXISTS(BEEPER)
+#if USE_BEEPER
   #include "../libs/buzzer.h"
 #endif
 
 
 inline void loud_kill(PGM_P const lcd_msg) {
   Running = false;
-  #if HAS_BUZZER && PIN_EXISTS(BEEPER)
+  #if USE_BEEPER
     for (uint8_t i = 20; i--;) {
       WRITE(BEEPER_PIN, HIGH); delay(25);
       WRITE(BEEPER_PIN, LOW); delay(80);