sync critical alert handling and vibration logic

Unified critical alert notifications by synchronizing border flashing and vibration through a single service. Removed legacy continuous vibration task and related code, replacing it with a timer-driven approach for both border and vibration pulses. Updated API in vibration_pwm and lvgl_updates to reflect new service, improving maintainability and synchronization of critical alert feedback.

Author: zjwhitehead

inc/sp140/lvgl/lvgl_updates.h

@@ -44,8 +44,26 @@ void updateLvglMainScreenWithTestData(const STR_DEVICE_DATA_140_V1& deviceData);
 // Flash animation functions
 void startCruiseIconFlash();
 void startArmFailIconFlash();
+
+/**
+ * @brief Starts the flashing of the critical alert border.
+ *
+ * This function should be called from a task that has acquired the LVGL mutex.
+ */
 void startCriticalBorderFlash();
+
+/**
+ * @brief Stops the flashing of the critical alert border.
+ *
+ * This function should be called from a task that has acquired the LVGL mutex.
+ */
 void stopCriticalBorderFlash();
+
+/**
+ * @brief Checks if the critical alert border is currently flashing.
+ *
+ * @return true if the border is flashing, false otherwise.
+ */
 bool isCriticalBorderFlashing();
 
 #endif // LVGL_UPDATES_H

inc/sp140/vibration_pwm.h

@@ -11,8 +11,7 @@ enum VibePattern {
   VIBE_TRIPLE_PULSE,
   VIBE_RAMP_UP,
   VIBE_RAMP_DOWN,
-  VIBE_WAVE,
-  VIBE_CRITICAL_CONTINUOUS  // New pattern for critical alerts
+  VIBE_WAVE
 };
 
 // Vibration request structure for queue
@@ -59,18 +58,51 @@ void executeVibePattern(VibePattern pattern);
 void customVibePattern(const uint8_t intensities[], const uint16_t durations[], int steps);
 
 /**
- * Start continuous vibration for critical alerts
+ * @brief Pulses the vibration motor for a specific duration and intensity.
+ *
+ * This is a non-blocking function that sends a request to the vibe queue.
+ *
+ * @param duration_ms The duration of the pulse in milliseconds.
+ * @param intensity The vibration intensity (0-255).
  */
-void startCriticalVibration();
+void pulseVibration(uint16_t duration_ms, uint8_t intensity);
 
 /**
- * Stop continuous vibration
+ * @brief Stops all vibration immediately.
+ *
+ * This function clears the vibration queue and turns off the PWM signal.
  */
-void stopCriticalVibration();
+void stopVibration();
 
 /**
- * Check if critical vibration is currently active
+ * @brief Initializes the critical alert service.
+ *
+ * This function sets up the necessary resources for handling synchronized critical alerts.
+ * It should be called once during system initialization.
  */
-bool isCriticalVibrationActive();
+void initCriticalAlertService();
+
+/**
+ * @brief Starts the critical alert notifications.
+ *
+ * Activates the synchronized vibration and border flashing. If alerts are
+ * already running, this function has no effect.
+ */
+void startCriticalAlerts();
+
+/**
+ * @brief Stops the critical alert notifications.
+ *
+ * Deactivates the vibration and border flashing. If alerts are not currently
+ * running, this function has no effect.
+ */
+void stopCriticalAlerts();
+
+/**
+ * @brief Checks if the critical alert system is currently active.
+ *
+ * @return true if critical alerts are active, false otherwise.
+ */
+bool isCriticalAlertActive();
 
 #endif  // INC_SP140_VIBRATION_PWM_H_

src/sp140/alert_display.cpp

@@ -5,7 +5,7 @@
 #include <algorithm>
 #include "../../inc/sp140/lvgl/lvgl_alerts.h"
 #include "../../inc/sp140/lvgl/lvgl_updates.h"
-#include "../../inc/sp140/vibration_pwm.h"  // For alert vibrations
+#include "../../inc/sp140/vibration_pwm.h"
 
 // ------------ Globals -------------
 QueueHandle_t alertEventQueue = NULL;
@@ -44,6 +44,9 @@ void initAlertDisplay() {
     return;
   }
 
+  // Init the new alert service
+  initCriticalAlertService();
+
   // Create aggregation task (low priority)
   xTaskCreate(alertAggregationTask, "AlertAgg", 3072, NULL, 1, &alertAggregationTaskHandle);
   USBSerial.println("[AlertDisplay] Init complete");
@@ -194,24 +197,14 @@ static void recalcCountsAndPublish() {
  */
 static void handleAlertVibration(const AlertCounts& newCounts, const AlertCounts& previousCounts) {
   if (newCounts.criticalCount > 0) {
-    // Start continuous vibration for critical alerts (if not already active)
-    if (!isCriticalVibrationActive()) {
-      startCriticalVibration();
-    }
-
-    // Start critical border flashing (if not already active)
-    if (!isCriticalBorderFlashing()) {
-      startCriticalBorderFlash();
+    // Use the new synchronized alert service
+    if (!isCriticalAlertActive()) {
+      startCriticalAlerts();
     }
   } else {
-    // Stop critical vibration if no critical alerts remain
-    if (isCriticalVibrationActive()) {
-      stopCriticalVibration();
-    }
-
-    // Stop critical border flashing if no critical alerts remain
-    if (isCriticalBorderFlashing()) {
-      stopCriticalBorderFlash();
+    // Stop synchronized alerts if no critical alerts remain
+    if (isCriticalAlertActive()) {
+      stopCriticalAlerts();
     }
 
     // Handle warning transitions (only when no critical alerts)

src/sp140/lvgl/lvgl_updates.cpp

@@ -1,6 +1,8 @@
 #include "../../../inc/sp140/lvgl/lvgl_updates.h"
 #include "../../../inc/sp140/esp32s3-config.h"
 #include "../../../inc/sp140/globals.h"
+#include "../../../inc/sp140/vibration_pwm.h"
+#include "../../../inc/sp140/shared-config.h"
 
 // Flash timer globals - definitions
 lv_timer_t* cruise_flash_timer = NULL;
@@ -175,79 +177,47 @@ void startArmFailIconFlash() {
 
 // --- Critical Alert Border Flashing Implementation ---
 static void critical_border_flash_timer_cb(lv_timer_t* timer) {
-  // This callback runs within the LVGL task handler, which is already protected by lvglMutex
+  // This callback runs within the LVGL task handler, so no mutex needed here.
+  if (critical_border != NULL) {
+    // Toggle visibility: 300ms on, 700ms off
+    bool is_on = !lv_obj_has_flag(critical_border, LV_OBJ_FLAG_HIDDEN);
+    if (is_on) {
+      lv_obj_add_flag(critical_border, LV_OBJ_FLAG_HIDDEN);
+      lv_timer_set_period(timer, 700); // Off duration
+    } else {
+      lv_obj_clear_flag(critical_border, LV_OBJ_FLAG_HIDDEN);
+      lv_timer_set_period(timer, 300); // On duration
 
-  if (critical_border == NULL) {
-    // Safety check
-    if (critical_border_flash_timer != NULL) {
-      lv_timer_del(critical_border_flash_timer);
-      critical_border_flash_timer = NULL;
+      // Trigger vibration pulse in sync with border "on"
+      if (ENABLE_VIBE) {
+        pulseVibration(300, 200); // 300ms pulse, intensity 200
+      }
     }
-    isFlashingCriticalBorder = false;
-    return;
-  }
-
-  // Toggle visibility
-  if (lv_obj_has_flag(critical_border, LV_OBJ_FLAG_HIDDEN)) {
-    lv_obj_clear_flag(critical_border, LV_OBJ_FLAG_HIDDEN);
-  } else {
-    lv_obj_add_flag(critical_border, LV_OBJ_FLAG_HIDDEN);
   }
 }
 
 void startCriticalBorderFlash() {
-  // This function can be called from other tasks, so protect with mutex
-  if (xSemaphoreTake(lvglMutex, pdMS_TO_TICKS(50)) == pdTRUE) {  // Use a timeout
-    if (critical_border == NULL) {
-      xSemaphoreGive(lvglMutex);
-      return;  // Can't flash if border doesn't exist
+  if (xSemaphoreTake(lvglMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
+    if (critical_border != NULL && !isFlashingCriticalBorder) {
+      isFlashingCriticalBorder = true;
+      lv_obj_clear_flag(critical_border, LV_OBJ_FLAG_HIDDEN); // Start visible
+      critical_border_flash_timer = lv_timer_create(critical_border_flash_timer_cb, 300, NULL);
     }
-
-    // If a flash timer is already running, delete it first
-    if (critical_border_flash_timer != NULL) {
-      lv_timer_del(critical_border_flash_timer);
-      critical_border_flash_timer = NULL;
-    }
-
-    // Reset state and start flashing
-    isFlashingCriticalBorder = true;
-
-    // Start with the border visible
-    lv_obj_clear_flag(critical_border, LV_OBJ_FLAG_HIDDEN);
-
-    // Create the timer (500ms interval for on/off cycle - matches vibration rate)
-    critical_border_flash_timer = lv_timer_create(critical_border_flash_timer_cb, 500, NULL);
-    if (critical_border_flash_timer == NULL) {
-      // Failed to create timer, reset state
-      isFlashingCriticalBorder = false;
-      lv_obj_add_flag(critical_border, LV_OBJ_FLAG_HIDDEN);  // Hide it again
-      USBSerial.println("Error: Failed to create critical border flash timer!");
-    }
-
     xSemaphoreGive(lvglMutex);
-  } else {
-     USBSerial.println("Warning: Failed to acquire LVGL mutex for startCriticalBorderFlash");
   }
 }
 
 void stopCriticalBorderFlash() {
-  // This function can be called from other tasks, so protect with mutex
-  if (xSemaphoreTake(lvglMutex, pdMS_TO_TICKS(50)) == pdTRUE) {  // Use a timeout
+  if (xSemaphoreTake(lvglMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
     if (critical_border_flash_timer != NULL) {
       lv_timer_del(critical_border_flash_timer);
       critical_border_flash_timer = NULL;
     }
-
-    isFlashingCriticalBorder = false;
-
-    // Hide the border
     if (critical_border != NULL) {
       lv_obj_add_flag(critical_border, LV_OBJ_FLAG_HIDDEN);
     }
-
+    isFlashingCriticalBorder = false;
     xSemaphoreGive(lvglMutex);
-  } else {
-     USBSerial.println("Warning: Failed to acquire LVGL mutex for stopCriticalBorderFlash");
   }
 }
 

src/sp140/vibration_pwm.cpp

@@ -1,6 +1,7 @@
 #include "sp140/vibration_pwm.h"
 #include "Arduino.h"
 #include "sp140/shared-config.h"
+#include "sp140/lvgl/lvgl_updates.h"
 
 const int VIBE_PWM_PIN = 46;  // TODO: move to config
 const int VIBE_PWM_FREQ = 1000;  // Adjust as needed
@@ -75,12 +76,6 @@ bool initVibeMotor() {
     return false;
   }
 
-  // Create critical vibration task - also pin to core 1, lower priority
-  xTaskCreatePinnedToCore(criticalVibeTask, "CriticalVibe", 2048, NULL, 1, &criticalVibeTaskHandle, 1);
-  if (criticalVibeTaskHandle == NULL) {
-    return false;
-  }
-
   return true;
 }
 
@@ -99,6 +94,29 @@ void pulseVibeMotor() {
   xQueueSend(vibeQueue, &request, 0);  // Don't wait if queue is full
 }
 
+/**
+ * @brief Pulses the vibration motor for a specific duration and intensity.
+ */
+void pulseVibration(uint16_t duration_ms, uint8_t intensity) {
+  if (!ENABLE_VIBE || vibeQueue == NULL) return;
+
+  VibeRequest request = {
+    .duration_ms = duration_ms,
+    .intensity = intensity
+  };
+  xQueueSend(vibeQueue, &request, 0);
+}
+
+/**
+ * @brief Stops all vibration immediately.
+ */
+void stopVibration() {
+  if (vibeQueue != NULL) {
+    xQueueReset(vibeQueue);
+  }
+  ledcWrite(VIBE_PWM_CHANNEL, 0);
+}
+
 /**
  * Run a custom vibration pattern using an array of intensities
  * @param pattern Array of intensity values (0-255)
@@ -177,11 +195,6 @@ void executeVibePattern(VibePattern pattern) {
       }
       ledcWrite(VIBE_PWM_CHANNEL, 0);
       break;
-
-    case VIBE_CRITICAL_CONTINUOUS:
-      // This pattern is handled by the continuous vibration task
-      startCriticalVibration();
-      break;
   }
 }
 
@@ -201,35 +214,45 @@ void customVibePattern(const uint8_t intensities[], const uint16_t durations[],
   ledcWrite(VIBE_PWM_CHANNEL, 0);
 }
 
+// Service state for critical alerts
+static bool g_critical_alert_active = false;
+
 /**
- * Start continuous vibration for critical alerts
+ * @brief Initializes the critical alert service.
  */
-void startCriticalVibration() {
-  if (!ENABLE_VIBE) return;
+void initCriticalAlertService() {
+  // Initialization can be expanded if needed in the future.
+}
 
-  if (!criticalVibrationActive) {
-    criticalVibrationActive = true;
-    if (criticalVibeTaskHandle != NULL) {
-      vTaskResume(criticalVibeTaskHandle);
-    }
+/**
+ * @brief Starts the critical alert notifications.
+ */
+void startCriticalAlerts() {
+  if (g_critical_alert_active) {
+    return;
   }
+  g_critical_alert_active = true;
+
+  // Start the single master LVGL timer, which will handle both border and vibration
+  startCriticalBorderFlash();
 }
 
 /**
- * Stop continuous vibration
+ * @brief Stops the critical alert notifications.
  */
-void stopCriticalVibration() {
-  if (criticalVibrationActive) {
-    criticalVibrationActive = false;
-    // Turn off vibration immediately
-    ledcWrite(VIBE_PWM_CHANNEL, 0);
-    // Task will suspend itself on next iteration
+void stopCriticalAlerts() {
+  if (!g_critical_alert_active) {
+    return;
   }
+  g_critical_alert_active = false;
+
+  // Stop the master LVGL timer
+  stopCriticalBorderFlash();
 }
 
 /**
- * Check if critical vibration is currently active
+ * @brief Checks if the critical alert system is currently active.
  */
-bool isCriticalVibrationActive() {
-  return criticalVibrationActive;
+bool isCriticalAlertActive() {
+  return g_critical_alert_active;
 }