Implement volume button hold/repeat with delay

Improve the button handling code so that a pressed and held button will
now generate additional press events after a short delay.

An acceleration curve is also applied so that events are generated with
increasing frequency the longer the button is held down.

Closes #323.

Author: dwhinham

CHANGELOG.md

@@ -20,6 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Update to libmt32emu v2.7.0.
 - Update to FluidSynth v2.3.1.
 - Update to inih r56.
+- Volume up/down buttons in the `simple_buttons` control scheme now repeat and accelerate when pressed and held (issue #323).
 - Updater: `config.txt` is now replaced on update, however the `avoid_warnings` setting is preserved (the only setting that matters to most users).
 - Updater: improved error handling.
 - Installer: less often-selected Wi-Fi countries have been moved to a separate list.

include/control/button.h

@@ -23,14 +23,18 @@
 #ifndef _button_h
 #define _button_h
 
-enum class TButton
+#include <circle/types.h>
+
+enum TButton : u8
 {
 	Button1,
 	Button2,
 	Button3,
 	Button4,
 
-	EncoderButton
+	EncoderButton,
+
+	Max,
 };
 
 #endif

include/control/control.h

@@ -29,6 +29,7 @@
 
 #include "control/rotaryencoder.h"
 #include "event.h"
+#include "optional.h"
 #include "utility.h"
 
 class CControl
@@ -51,15 +52,39 @@ class CControl
 	static constexpr size_t ButtonStateHistoryLength = 16;
 	static constexpr size_t ButtonStateHistoryMask   = ButtonStateHistoryLength - 1;
 
+	static constexpr u32 RepeatDelayMicros 	   = 500000;	// 500ms
+	static constexpr u32 RepeatAccelTimeMicros = 3000000;	// 3s
+	static constexpr u32 MaxRepeatPeriodMicros = 100000;	// 10Hz
+	static constexpr u32 MinRepeatPeriodMicros = 20000;	// 50Hz
+
 	TEventQueue* m_pEventQueue;
 	CUserTimer m_Timer;
 
 	// Debouncing
 	u8 m_ButtonStateHistory[ButtonStateHistoryLength];
 	size_t m_nButtonStateHistoryIndex;
+
+	// State tracking
 	u8 m_nButtonState;
 	u8 m_nLastButtonState;
 
+	// Repeat
+	TOptional<u8> m_RepeatButton;
+	u32 m_PressedTime;
+	u32 m_RepeatTime;
+
+	static inline u32 RepeatPeriod(u32 nPressedDuration)
+	{
+		return Utility::Lerp
+		(
+			nPressedDuration,
+			0,
+			RepeatAccelTimeMicros,
+			MaxRepeatPeriodMicros,
+			MinRepeatPeriodMicros
+		);
+	}
+
 	static void InterruptHandler(CUserTimer* pUserTimer, void* pParam);
 };
 

include/event.h

@@ -33,6 +33,7 @@ struct TButtonEvent
 {
 	TButton Button;
 	bool bPressed;
+	bool bRepeat;
 };
 
 struct TEncoderEvent

include/utility.h

@@ -61,6 +61,12 @@ namespace Utility
 		return nLHS > nRHS ? nLHS : nRHS;
 	}
 
+	// Function for performing a linear interpolation of a value
+	constexpr float Lerp(float nValue, float nMinA, float nMaxA, float nMinB, float nMaxB)
+	{
+		return nMinB + (nValue - nMinA) * ((nMaxB - nMinB) / (nMaxA - nMinA));
+	}
+
 	// Return number of elements in an array
 	template <class T, size_t N>
 	constexpr size_t ArraySize(const T(&)[N]) { return N; }

src/control/control.cpp

@@ -21,6 +21,7 @@
 //
 
 #include <circle/interrupt.h>
+#include <circle/timer.h>
 
 #include "control/control.h"
 
@@ -33,7 +34,10 @@ CControl::CControl(TEventQueue& pEventQueue)
 	  m_ButtonStateHistory{0},
 	  m_nButtonStateHistoryIndex(0),
 	  m_nButtonState(0),
-	  m_nLastButtonState(0)
+	  m_nLastButtonState(0),
+	  m_RepeatButton(),
+	  m_PressedTime(0),
+	  m_RepeatTime(0)
 {
 }
 
@@ -55,21 +59,52 @@ void CControl::Update()
 	{
 		Event.Type = TEventType::Button;
 
-		for (u8 i = 0; i < 8; ++i)
+		for (u8 i = 0; i < TButton::Max; ++i)
 		{
 			const bool bCurrentState = m_nButtonState & (1 << i);
 			const bool bLastState    = m_nLastButtonState & (1 << i);
 
 			if (bCurrentState != bLastState)
 			{
+				if (bCurrentState)
+				{
+					m_RepeatButton = i;
+					m_PressedTime = CTimer::GetClockTicks();
+					m_RepeatTime = 0;
+				}
+				else if (m_RepeatButton && m_RepeatButton.Value() == i)
+					m_RepeatButton.Reset();
+
 				Event.Button.Button   = static_cast<TButton>(i);
 				Event.Button.bPressed = bCurrentState;
+				Event.Button.bRepeat = false;
 				m_pEventQueue->Enqueue(Event);
 			}
 		}
 
 		m_nLastButtonState = m_nButtonState;
 	}
+
+	// Handle repeat
+	if (m_RepeatButton)
+	{
+		const u32 nTicks = CTimer::GetClockTicks();
+		const u32 nPressedDuration = nTicks - m_PressedTime;
+
+		if (nPressedDuration > RepeatDelayMicros)
+		{
+			if (m_RepeatTime == 0)
+				m_RepeatTime = nTicks;
+			else if (nTicks - m_RepeatTime > RepeatPeriod(nPressedDuration - RepeatDelayMicros))
+			{
+				Event.Button.Button   = static_cast<TButton>(m_RepeatButton.Value());
+				Event.Button.bPressed = true;
+				Event.Button.bRepeat = true;
+				m_pEventQueue->Enqueue(Event);
+				m_RepeatTime = nTicks;
+			}
+		}
+	}
 }
 
 void CControl::DebounceButtonState(u8 nState, u8 nMask)

src/mt32pi.cpp

@@ -1068,15 +1068,15 @@ void CMT32Pi::ProcessButtonEvent(const TButtonEvent& Event)
 	if (!Event.bPressed)
 		return;
 
-	if (Event.Button == TButton::Button1)
+	if (Event.Button == TButton::Button1 && !Event.bRepeat)
 	{
 		// Swap synths
 		if (m_pCurrentSynth == m_pMT32Synth)
 			SwitchSynth(TSynth::SoundFont);
 		else
 			SwitchSynth(TSynth::MT32);
 	}
-	else if (Event.Button == TButton::Button2 && Event.bPressed)
+	else if (Event.Button == TButton::Button2 && !Event.bRepeat)
 	{
 		if (m_pCurrentSynth == m_pMT32Synth)
 			NextMT32ROMSet();