Add Battery Status Display to Session View 🔋🪫

src/deluge/deluge.cpp

@@ -16,6 +16,29 @@
  */
 
 #include "deluge.h"
+#include "system/power_manager.h"
+#include "gui/views/session_view.h"
+#include "gui/views/view.h"
+#include "hid/led/indicator_leds.h"
+#include "hid/led/pad_leds.h"
+#include "hid/buttons.h"
+#include "hid/encoders.h"
+#include "hid/matrix/matrix_driver.h"
+#include "hid/display/oled.h"
+#include "hid/display/seven_segment.h"
+#include "io/debug/print.h"
+#include "io/midi/midi_engine.h"
+#include "drivers/uart/uart.h"
+#include "processing/engines/audio_engine.h"
+#include "storage/file_item.h"
+#include "storage/storage_manager.h"
+#include "util/functions.h"
+#include "util/cfunctions.h"
+#include "gui/ui/root_ui.h"
+#include "gui/ui_timer_manager.h"
+#include "model/settings/runtime_feature_settings.h"
+#include "model/settings/runtime_feature_settings.h"
+#include "fatfs/fatfs.hpp"
 
 #include "RZA1/sdhi/inc/sdif.h"
 #include "definitions_cxx.hpp"
@@ -29,42 +52,27 @@
 #include "gui/ui/save/save_song_ui.h"
 #include "gui/ui/sound_editor.h"
 #include "gui/ui/ui.h"
-#include "gui/ui_timer_manager.h"
 #include "gui/views/arranger_view.h"
 #include "gui/views/audio_clip_view.h"
 #include "gui/views/automation_view.h"
 #include "gui/views/instrument_clip_view.h"
-#include "gui/views/session_view.h"
-#include "gui/views/view.h"
-#include "hid/buttons.h"
-#include "hid/display/display.h"
-#include "hid/display/oled.h"
-#include "hid/display/seven_segment.h"
-#include "hid/encoders.h"
-#include "hid/led/indicator_leds.h"
-#include "hid/led/pad_leds.h"
-#include "hid/matrix/matrix_driver.h"
 #include "io/debug/log.h"
 #include "io/midi/midi_device_manager.h"
-#include "io/midi/midi_engine.h"
 #include "io/midi/midi_follow.h"
 #include "lib/printf.h" // IWYU pragma: keep this over rides printf with a non allocating version
 #include "memory/general_memory_allocator.h"
 #include "model/clip/instrument_clip.h"
 #include "model/clip/instrument_clip_minder.h"
 #include "model/output.h"
-#include "model/settings/runtime_feature_settings.h"
 #include "model/song/song.h"
 #include "modulation/params/param_manager.h"
 #include "playback/mode/arrangement.h"
 #include "playback/mode/session.h"
-#include "processing/engines/audio_engine.h"
 #include "processing/engines/cv_engine.h"
 #include "scheduler_api.h"
 #include "storage/audio/audio_file_manager.h"
 #include "storage/flash_storage.h"
 #include "storage/smsysex.h"
-#include "storage/storage_manager.h"
 #include "util/misc.h"
 #include "util/pack.h"
 #include <stdlib.h>
@@ -152,48 +160,31 @@ void inputRoutine() {
 		AudioEngine::lineInPluggedIn = lineInNow;
 	}
 
-	// Battery voltage
-	// If analog read is ready...
-
-	if (ADC.ADCSR & (1 << 15)) {
-		int32_t numericReading = ADC.ADDRF;
-		// Apply LPF
-		int32_t voltageReading = numericReading * 3300;
-		int32_t distanceToGo = voltageReading - voltageReadingLastTime;
-		voltageReadingLastTime += distanceToGo >> 4;
-
-		// We only >> by 15 so that we intentionally double the value, because the incoming voltage is halved by a
-		// resistive divider already
-		batteryMV = (voltageReadingLastTime) >> 15;
-		// D_PRINT("batt mV: ");
-		// D_PRINTLN(batteryMV);
-
-		// See if we've reached threshold to change verdict on battery level
-
-		if (batteryCurrentRegion == 0) {
-			if (batteryMV > 2950) {
-makeBattLEDSolid:
-				batteryCurrentRegion = 1;
-				setOutputState(BATTERY_LED.port, BATTERY_LED.pin, false);
-				uiTimerManager.unsetTimer(TimerName::BATT_LED_BLINK);
-			}
-		}
-		else if (batteryCurrentRegion == 1) {
-			if (batteryMV < 2900) {
-				batteryCurrentRegion = 0;
+	// Update power management
+	auto& powerManager = deluge::system::powerManager;
+	powerManager.update();
+
+	// Update battery LED based on power status
+	if (powerManager.isExternalPowerConnected()) {
+		// When on external power, LED is solid
+		setOutputState(BATTERY_LED.port, BATTERY_LED.pin, true);
+		uiTimerManager.unsetTimer(TimerName::BATT_LED_BLINK);
+	} else {
+		// On battery, LED behavior depends on battery level
+		int32_t batteryPercent = powerManager.getBatteryPercentage();
+		if (batteryPercent > 80) {
+			// High battery - solid LED
+			setOutputState(BATTERY_LED.port, BATTERY_LED.pin, true);
+			uiTimerManager.unsetTimer(TimerName::BATT_LED_BLINK);
+		} else if (batteryPercent > 20) {
+			// Medium battery - LED off
+			setOutputState(BATTERY_LED.port, BATTERY_LED.pin, false);
+			uiTimerManager.unsetTimer(TimerName::BATT_LED_BLINK);
+		} else {
+			// Low battery - blinking LED
+			if (!uiTimerManager.isTimerSet(TimerName::BATT_LED_BLINK)) {
 				batteryLEDBlink();
 			}
-
-			else if (batteryMV > 3300) {
-				batteryCurrentRegion = 2;
-				setOutputState(BATTERY_LED.port, BATTERY_LED.pin, true);
-				uiTimerManager.unsetTimer(TimerName::BATT_LED_BLINK);
-			}
-		}
-		else {
-			if (batteryMV < 3200) {
-				goto makeBattLEDSolid;
-			}
 		}
 	}
 
@@ -667,7 +658,7 @@ void mainLoop() {
 		audioRecorder.slowRoutine();
 
 #if AUTOPILOT_TEST_ENABLED
-		autoPilotStuff();
+	autoPilotStuff();
 #endif
 	}
 }
@@ -1395,3 +1386,6 @@ void spamMode() {
 }
 
 #endif
+
+class View;  // Forward declaration
+extern View view;

src/deluge/deluge.h

@@ -51,6 +51,8 @@ extern const size_t l10n_STRING_FOR_USB_DEVICE_NOT_RECOGNIZED;
 
 char const* l10n_get(size_t s);
 
+extern uint8_t batteryCurrentRegion;
+
 #ifdef __cplusplus
 }
 #endif

src/deluge/gui/views/session_view.cpp

@@ -17,6 +17,8 @@
 
 #include "gui/views/session_view.h"
 #include "definitions_cxx.hpp"
+#include "deluge/system/power_manager.h"  // Move this up before other includes
+#include "deluge/hid/usb_check.h"
 #include "dsp/compressor/rms_feedback.h"
 #include "extern.h"
 #include "gui/colour/colour.h"
@@ -91,6 +93,9 @@ extern "C" {
 using namespace deluge;
 using namespace gui;
 
+extern uint16_t batteryMV;           // Battery voltage in millivolts
+extern uint8_t batteryCurrentRegion; // Battery level (0-3)
+
 SessionView sessionView{};
 
 SessionView::SessionView() {
@@ -1889,7 +1894,6 @@ void SessionView::renderOLED(deluge::hid::display::oled_canvas::Canvas& canvas)
 		stemExport.displayStemExportProgressOLED(StemExportType::CLIP);
 		return;
 	}
-
 	UI* currentUI = getCurrentUI();
 	if (currentUIMode == UI_MODE_CLIP_PRESSED_IN_SONG_VIEW) {
 		view.displayOutputName(getCurrentClip()->output, true, getCurrentClip());
@@ -2026,6 +2030,9 @@ void SessionView::renderViewDisplay() {
 	int32_t yPos = OLED_MAIN_TOPMOST_PIXEL + 3;
 #endif
 
+	// Draw battery status
+	displayBatteryStatus(canvas, false);
+
 	DEF_STACK_STRING_BUF(tempoBPM, 10);
 	lastDisplayedTempo = playbackHandler.calculateBPM(playbackHandler.getTimePerInternalTickFloat());
 	playbackHandler.getTempoStringForOLED(lastDisplayedTempo, tempoBPM);
@@ -2083,6 +2090,67 @@ void SessionView::displayTempoBPM(deluge::hid::display::oled_canvas::Canvas& can
 	canvas.drawGraphicMultiLine(deluge::hid::display::OLED::metronomeIcon, metronomeIconStartX, yPos, 7);
 }
 
+void SessionView::displayBatteryStatus(deluge::hid::display::oled_canvas::Canvas& canvas, bool clearArea) {
+    int32_t x = 0;
+    int32_t y = OLED_MAIN_TOPMOST_PIXEL + 4;
+
+    // Get power status
+    bool usbPowerConnected = deluge::system::powerManager.isExternalPowerConnected();
+    int32_t batteryPercent = deluge::system::powerManager.getBatteryPercentage();
+    bool isCharging = deluge::system::powerManager.isCharging();
+    int32_t voltage = deluge::system::powerManager.getStableVoltage();
+
+    // Battery icon dimensions
+    int32_t iconWidth = 12;
+    int32_t iconHeight = 7;
+    int32_t iconSpacing = 3;
+
+    if (clearArea) {
+        // Calculate width for icon + text + debug info
+        int32_t maxTextWidth = kTextSpacingX * 30; // Increased for debug info
+        canvas.clearAreaExact(x, y, x + iconWidth + 1 + iconSpacing + maxTextWidth, y + iconHeight);
+    }
+
+    // Draw battery outline
+    canvas.drawRectangle(x, y, x + iconWidth - 1, y + iconHeight - 1);
+    canvas.drawRectangle(iconWidth - 1, y + 2, iconWidth, y + 5);
+
+    // When on external power
+    if (usbPowerConnected) {
+        if (isCharging) {
+            // Draw charging animation
+            for (int32_t i = 0; i < 3; i++) {
+                int32_t baseX = x + 2 + (i * 3);
+                canvas.drawPixel(baseX, y + 2);
+                canvas.drawPixel(baseX + 1, y + 3);
+                canvas.drawPixel(baseX, y + 4);
+            }
+            canvas.drawString("CHG", x + iconWidth + iconSpacing, y - 1, kTextSpacingX, kTextSpacingY);
+        } else {
+            // Fill battery completely
+            for (int32_t i = 0; i < 3; i++) {
+                int32_t segmentX = x + 2 + (i * 3);
+                canvas.drawRectangle(segmentX, y + 2, segmentX + 1, y + 4);
+            }
+            canvas.drawString("USB", x + iconWidth + iconSpacing, y - 1, kTextSpacingX, kTextSpacingY);
+        }
+    }
+    // On battery power
+    else {
+        int32_t numSegments = (batteryPercent * 3) / 100;
+        for (int32_t i = 0; i < numSegments; i++) {
+            int32_t segmentX = x + 2 + (i * 3);
+            canvas.drawRectangle(segmentX, y + 2, segmentX + 1, y + 4);
+        }
+        canvas.drawString("BAT", x + iconWidth + iconSpacing, y - 1, kTextSpacingX, kTextSpacingY);
+    }
+
+    // Draw debug info after the battery status
+    char debugText[32];
+    snprintf(debugText, sizeof(debugText), " %dv1 %d%%", voltage, batteryPercent);
+    canvas.drawString(debugText, x + iconWidth + iconSpacing + 30, y - 1, kTextSpacingX, kTextSpacingY);
+}
+
 void SessionView::displayCurrentRootNoteAndScaleName(deluge::hid::display::oled_canvas::Canvas& canvas,
                                                      StringBuf& rootNoteAndScaleName, bool clearArea) {
 
@@ -2195,6 +2263,7 @@ void SessionView::graphicsRoutine() {
 
 	if (display->haveOLED()) {
 		displayPotentialTempoChange(this);
+		displayPotentialBatteryChange(batteryMV);
 	}
 
 	bool reallyNoTickSquare = (!playbackHandler.isEitherClockActive() || currentUIMode == UI_MODE_EXPLODE_ANIMATION
@@ -2344,6 +2413,7 @@ void SessionView::graphicsRoutine() {
 // checks if tempo has changed since it was last rendered on the display and updates it if required
 void SessionView::displayPotentialTempoChange(UI* ui) {
 	// check UI in case graphics routine is called while we're in another UI (e.g. menu)
+
 	if (getCurrentUI() == ui) {
 		float tempo = playbackHandler.calculateBPMForDisplay();
 		float diff = std::abs(tempo - lastDisplayedTempo);
@@ -2358,6 +2428,20 @@ void SessionView::displayPotentialTempoChange(UI* ui) {
 	}
 }
 
+// checks if battery voltage has changed and updates it if required
+void SessionView::displayPotentialBatteryChange(uint16_t newBatteryMV) {
+	// Only update display if we're in the session view
+
+	if (getCurrentUI() == this) {
+		// Only redraw display if voltage has changed significantly (50mV roughly 5% of full scale)
+		if (abs(newBatteryMV - lastDisplayedBatteryMV) > 50) {
+			lastDisplayedBatteryMV = newBatteryMV;
+			displayBatteryStatus(deluge::hid::display::OLED::main);
+			deluge::hid::display::OLED::markChanged();
+		}
+	}
+}
+
 /// display number of bars or quarter notes remaining until a launch event
 int32_t SessionView::displayLoopsRemainingPopup(bool ephemeral) {
 	int32_t sixteenthNotesRemaining = session.getNumSixteenthNotesRemainingTilLaunch();

src/deluge/gui/views/session_view.h

@@ -43,6 +43,9 @@ constexpr uint32_t kGridHeight = kDisplayHeight;
 
 class SessionView final : public ClipNavigationTimelineView {
 public:
+	static constexpr int BATTERY_MV_MAX = 4200;  // 4.2V fully charged
+	static constexpr int BATTERY_MV_MIN = 2900;  // 2.9V cutoff voltage
+
 	SessionView();
 	bool getGreyoutColsAndRows(uint32_t* cols, uint32_t* rows) override;
 	bool opened() override;
@@ -147,6 +150,10 @@ class SessionView final : public ClipNavigationTimelineView {
 	void displayTempoBPM(deluge::hid::display::oled_canvas::Canvas& canvas, StringBuf& tempoBPM, bool clearArea);
 	float lastDisplayedTempo = 0;
 
+	// display battery status
+	void displayPotentialBatteryChange(uint16_t newBatteryMV);
+	uint16_t lastDisplayedBatteryMV = 0;
+
 	// display root note and scale name
 	void displayCurrentRootNoteAndScaleName(deluge::hid::display::oled_canvas::Canvas& canvas,
 	                                        StringBuf& rootNoteAndScaleName, bool clearArea);
@@ -155,6 +162,9 @@ class SessionView final : public ClipNavigationTimelineView {
 	// convert instrument clip to audio clip
 	void replaceInstrumentClipWithAudioClip(Clip* clip);
 
+	// Draw battery status
+	void displayBatteryStatus(deluge::hid::display::oled_canvas::Canvas& canvas, bool clearArea = true);
+
 private:
 	// These and other (future) commandXXX methods perform actions triggered by HID, but contain
 	// no dispatch logic.