Add Battery Status Display to Session View 🔋🪫

src/deluge/deluge.cpp

@@ -165,11 +165,15 @@ void inputRoutine() {
 		// 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
+		int32_t newBatteryMV = batteryMV;
+
+		// Update battery display if voltage has changed significantly
+		// TODO: Do we need this, can it be self-contained in session_view?
+		sessionView.displayPotentialBatteryChange(newBatteryMV);
 
+
+		// See if we've reached threshold to change verdict on battery level
 		if (batteryCurrentRegion == 0) {
 			if (batteryMV > 2950) {
 makeBattLEDSolid:
@@ -183,7 +187,11 @@ void inputRoutine() {
 				batteryCurrentRegion = 0;
 				batteryLEDBlink();
 			}
-
+			else if (batteryMV > 3800) {
+				batteryCurrentRegion = 3;
+				setOutputState(BATTERY_LED.port, BATTERY_LED.pin, true);
+				uiTimerManager.unsetTimer(TimerName::BATT_LED_BLINK);
+			}
 			else if (batteryMV > 3300) {
 				batteryCurrentRegion = 2;
 				setOutputState(BATTERY_LED.port, BATTERY_LED.pin, true);

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,7 @@
 
 #include "gui/views/session_view.h"
 #include "definitions_cxx.hpp"
+#include "deluge/hid/usb_check.h"
 #include "dsp/compressor/rms_feedback.h"
 #include "extern.h"
 #include "gui/colour/colour.h"
@@ -91,6 +92,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 +1893,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 +2029,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 +2089,59 @@ 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;
+
+	// Check if USB power is connected. Must be a better way to do this than just checking the battery voltage.
+	bool usbPowerConnected = (batteryMV > 4600);
+
+	int32_t batteryPercent = (batteryMV - BATTERY_MV_MIN) * 100 / (BATTERY_MV_MAX - BATTERY_MV_MIN);
+
+	// Battery icon dimensions
+	int32_t iconWidth = 12; // Main body width
+	int32_t iconHeight = 7;
+	int32_t iconSpacing = 3;
+
+	if (clearArea) {
+		// Calculate exact text width for max "100%" (4 chars)
+		// TODO - 11 for now - to also show mV value
+		int32_t maxTextWidth = kTextSpacingX * 11;
+		canvas.clearAreaExact(x, y, x + iconWidth + 1 + iconSpacing + maxTextWidth, y + iconHeight);
+	}
+
+	// Draw battery outline
+	canvas.drawRectangle(x, y, x + iconWidth - 1, y + iconHeight - 1); // Body (11x7)
+	canvas.drawRectangle(iconWidth - 1, y + 2, iconWidth, y + 5);      // Terminal (1x3)
+
+	// When USB power is connected, show charging arrows pattern
+	if (usbPowerConnected) {
+		// Draw three arrow patterns using checkerboard pixels
+		for (int32_t i = 0; i < 3; i++) {
+			int32_t baseX = x + 2 + (i * 3);
+			// Three pixel arrow
+			canvas.drawPixel(baseX, y + 2);     // Top pixel
+			canvas.drawPixel(baseX + 1, y + 3); // Middle pixel
+			canvas.drawPixel(baseX, y + 4);     // Bottom pixel
+		}
+
+		// When USB connected, just show "USB" text
+		canvas.drawString("USB", x + iconWidth + iconSpacing, y - 1, kTextSpacingX, kTextSpacingY);
+	}
+	// Or show battery segments based on battery level (0-3)
+	else if (batteryCurrentRegion > 0) {
+		for (int32_t i = 0; i < batteryCurrentRegion; i++) {
+			int32_t segmentX = x + 2 + (i * 3);                         // 2px segment + 1px gap
+			canvas.drawRectangle(segmentX, y + 2, segmentX + 1, y + 4); // 2px wide, 3px tall
+		}
+
+		// Draw percentage text only when on battery power
+		char text[16];
+		snprintf(text, sizeof(text), "%d%% %dmV", batteryPercent, batteryMV);
+		canvas.drawString(text, x + iconWidth + iconSpacing, y - 1, kTextSpacingX, kTextSpacingY);
+	}
+}
+
 void SessionView::displayCurrentRootNoteAndScaleName(deluge::hid::display::oled_canvas::Canvas& canvas,
                                                      StringBuf& rootNoteAndScaleName, bool clearArea) {
 
@@ -2195,6 +2254,7 @@ void SessionView::graphicsRoutine() {
 
 	if (display->haveOLED()) {
 		displayPotentialTempoChange(this);
+		displayPotentialBatteryChange(batteryMV);
 	}
 
 	bool reallyNoTickSquare = (!playbackHandler.isEitherClockActive() || currentUIMode == UI_MODE_EXPLODE_ANIMATION
@@ -2344,6 +2404,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 +2419,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.

src/deluge/hid/usb_check.c

@@ -0,0 +1,8 @@
+#include "RZA1/usb/r_usb_basic/r_usb_basic_if.h"
+#include "RZA1/usb/r_usb_basic/src/driver/inc/r_usb_basic_define.h"
+#include "RZA1/usb/r_usb_basic/src/driver/inc/r_usb_extern.h"
+
+uint16_t check_usb_power_status(void) {
+    uint16_t status = usb_pstd_chk_vbsts();
+    return status;
+}

src/deluge/hid/usb_check.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint16_t check_usb_power_status(void);
+
+#define USB_POWER_ATTACHED 0x0040u
+
+#ifdef __cplusplus
+}
+#endif