feat(ir): add configurable long-press actions for IR remote buttons

Each learned IR button can now carry a second command that fires when the
button is held, so a short tap and a long hold run different actions (like
the physical buttons already do).

IR sends no "released" event, so release is inferred from the repeat-frame
stream: a held button keeps re-sending frames, and once they stop arriving
(IR_HOLD_RELEASE_MS gap) the button counts as released. A button with a
long action fires the long action once the hold passes a configurable
threshold and the short action on release; buttons without a long action
keep their previous instant behavior (volume still ramps while held).

- IrMapping gains a longCmd byte; the NVS blob moves to key "irMap2" with a
  one-time migration from the legacy 3-byte "irMap" layout so existing
  remotes survive the update (a separate key avoids the 3-vs-4 byte stride
  ambiguity).
- Threshold persisted in NVS ("irLongMs", default 600 ms, clamped 200-5000),
  configurable via Settings -> IR. Exposed as ir.longPressMs and per-entry
  ir.map[].longCmd in settingsToJSON / JSONToSettings, so it round-trips
  through GET/POST /settings and the full backup/restore.
- Web UI: second "long press" command column (with a "none" option) plus a
  ms threshold input; de/en/fr strings; demo mock + README updated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: fhirschmann

README.md

@@ -268,6 +268,7 @@ neon logo that doubles as the SVG favicon ([`7be5254`](../../commit/7be5254)):
 | Don't resume a barely-started audiobook: if the card is pulled within the first few seconds (new **"Don't resume if pulled within (sec.)"** general setting, NVS key `minResumeSec`, default 20 s, 0 = off), the resume point is reset to the very start instead of saving the couple of seconds played — so a briefly-sampled card starts cleanly from the beginning next time rather than a few seconds in. Gated to the very first track of the position-saving audiobook modes, so genuine mid-book progress is never discarded | [`7cacec7`](../../commit/7cacec7) |
 | **Smart forward/backward seek with press-coalescing** (`CMD_SMART_FORWARDS` / `CMD_SMART_BACKWARDS`, action codes 190/191; also track-control codes 10/11 for MQTT): on an audiobook that is a single long file these commands seek *inside* the file; on a playlist of several files they fall back to next/previous track. Rapid presses are bundled into one jump so the decoder re-syncs once instead of once per press (the old per-press seek felt sluggish on FLAC and dropped presses during the multi-second resync). A forward jump past the end of a single file **clamps to a few seconds before the end and keeps playing** instead of ending the book (`setAudioPlayTime` instead of `setTimeOffset`'s `stopSong`). On a single-file audiobook this works even in the first second after a tap (before the duration is known), and the target is clamped to the `setAudioPlayTime` 16-bit range so files longer than ~18 h can't wrap. The step is configurable in the web UI (General → options → **"Smart seek step (sec.)"**, NVS key `seekStep`, default 300 s = 5 min). Bind them to physical buttons in the **Buttons** settings tab. The plain `CMD_SEEK_FORWARDS`/`BACKWARDS` 30 s jump (`jumpOffset`) and the upstream next/previous-track behavior are both unchanged | [`ba3628e`](../../commit/ba3628e) |
 | **Infrared remote control** enabled on the complete board: an IR receiver (e.g. VS1838B) on `IRLED_PIN` (GPIO 5) drives play/pause, next/previous, first/last track, volume, mute, shutdown, Bluetooth and FTP via the `RC_*` command codes in `settings-complete.h`. The mapping defaults to empty so an un-learned remote does nothing until its codes are entered | [`9dbe588`](../../commit/9dbe588) |
+| **IR long-press actions**: every learned IR button can carry a **second command that fires when the button is held** — short tap and long hold trigger different actions, just like the physical buttons. IR sends no "released" event, so the firmware infers release from the repeat-frame stream: the long action fires once the hold passes a **configurable threshold** (Settings → IR → **"Long-press threshold"**, default 600 ms, NVS key `irLongMs`), the short action fires on release. Buttons left without a long action keep firing instantly (volume still ramps while held). Set per button in the IR settings tab and carried through backup/restore | |
 
 ### Virtual RFID cards
 

html/locales/de.json

@@ -58,6 +58,9 @@
 		"title": "Infrarot-Fernbedienung",
 		"intro": "Lerne die Tasten deiner Fernbedienung an und ordne jeder ein Kommando zu. Klicke auf „Anlernen“ und drücke dann die Taste auf der Fernbedienung – der empfangene Code wird automatisch eingetragen. Nicht vergessen zu speichern.",
 		"command": "Kommando",
+		"longCommand": "Lang drücken",
+		"longPressLabel": "Schwelle für langes Drücken",
+		"longPressHint": "Wie lange eine Taste gehalten werden muss, um die Lang-Aktion auszulösen (200–5000 ms). Tasten ohne Lang-Aktion reagieren weiterhin sofort.",
 		"code": "IR-Code",
 		"learn": "Anlernen",
 		"learnPrompt": "Drücke jetzt eine Taste auf der Fernbedienung…",
@@ -68,6 +71,7 @@
 		"timeout": "Kein IR-Signal empfangen – Anlernen abgebrochen.",
 		"duplicate": "Derselbe Code ist mehrfach zugeordnet; der erste Treffer gewinnt.",
 		"cmd": {
+			"none": "— (keine)",
 			"playpause": "Wiedergabe / Pause",
 			"next": "Nächster Titel",
 			"prev": "Vorheriger Titel",

html/locales/en.json

@@ -58,6 +58,9 @@
 		"title": "Infrared remote control",
 		"intro": "Teach the buttons of your remote and assign each one a command. Click “Learn”, then press the button on the remote — the received code is filled in automatically. Don't forget to save.",
 		"command": "Command",
+		"longCommand": "Long press",
+		"longPressLabel": "Long-press threshold",
+		"longPressHint": "How long a button must be held to trigger the long-press action (200–5000 ms). Buttons without a long action still react instantly.",
 		"code": "IR code",
 		"learn": "Learn",
 		"learnPrompt": "Press a button on the remote now…",
@@ -68,6 +71,7 @@
 		"timeout": "No IR signal received — learning cancelled.",
 		"duplicate": "The same code is mapped more than once; the first match wins.",
 		"cmd": {
+			"none": "— (none)",
 			"playpause": "Play / Pause",
 			"next": "Next track",
 			"prev": "Previous track",

html/locales/fr.json

@@ -58,6 +58,9 @@
 		"title": "Télécommande infrarouge",
 		"intro": "Apprenez les touches de votre télécommande et associez à chacune une commande. Cliquez sur « Apprendre », puis appuyez sur la touche de la télécommande — le code reçu est rempli automatiquement. N'oubliez pas d'enregistrer.",
 		"command": "Commande",
+		"longCommand": "Appui long",
+		"longPressLabel": "Seuil d’appui long",
+		"longPressHint": "Durée pendant laquelle une touche doit être maintenue pour déclencher l’action d’appui long (200–5000 ms). Les touches sans action longue réagissent toujours immédiatement.",
 		"code": "Code IR",
 		"learn": "Apprendre",
 		"learnPrompt": "Appuyez maintenant sur une touche de la télécommande…",
@@ -68,6 +71,7 @@
 		"timeout": "Aucun signal IR reçu — apprentissage annulé.",
 		"duplicate": "Le même code est associé plusieurs fois ; la première correspondance l'emporte.",
 		"cmd": {
+			"none": "— (aucune)",
 			"playpause": "Lecture / Pause",
 			"next": "Piste suivante",
 			"prev": "Piste précédente",

html/management.html

@@ -3063,11 +3063,20 @@ <h5 class="modal-title" data-i18n="tools.nvs.erase.title"></h5>
 				<fieldset id="irConfig">
 					<legend class="w-auto" data-i18n="ir.title"></legend>
 					<p class="small text-secondary" data-i18n="ir.intro"></p>
+					<div class="mb-3" style="max-width: 24rem;">
+						<label class="form-label" for="irLongPressMs" data-i18n="ir.longPressLabel"></label>
+						<div class="input-group">
+							<input type="number" class="form-control" id="irLongPressMs" min="200" max="5000" step="50" value="600">
+							<span class="input-group-text">ms</span>
+						</div>
+						<div class="form-text" data-i18n="ir.longPressHint"></div>
+					</div>
 					<div class="table-responsive">
 						<table class="table table-sm align-middle mb-2" id="irMappingTable">
 							<thead>
 								<tr>
 									<th data-i18n="ir.command"></th>
+									<th data-i18n="ir.longCommand"></th>
 									<th data-i18n="ir.code"></th>
 									<th class="text-end"></th>
 								</tr>
@@ -5683,6 +5692,7 @@ <h5 class="modal-title" data-i18n="tools.nvs.erase.title"></h5>
 			let irSettings = settings.ir;
 			if (irSettings) {
 				document.getElementById('settings-ir-subtab').setAttribute('data-visible', true);
+				if (irSettings.longPressMs) { document.getElementById('irLongPressMs').value = irSettings.longPressMs; }
 				buildIrTable(irSettings.map || []);
 			}
 			// playlist
@@ -7915,37 +7925,50 @@ <h5 class="modal-title" data-i18n="tools.nvs.erase.title"></h5>
 		}
 
 		// Build the command <select> for a row, marking `cmd` as selected.
-		function irBuildCommandSelect(cmd) {
+		function irBuildCommandSelect(cmd, includeNone) {
 			var sel = document.createElement('select');
-			sel.className = 'form-select form-select-sm ir-cmd';
+			sel.className = 'form-select form-select-sm ' + (includeNone ? 'ir-longcmd' : 'ir-cmd');
+			var num = (cmd === null || cmd === undefined) ? (includeNone ? 0 : null) : Number(cmd);
 			var known = false;
+			if (includeNone) {
+				var none = document.createElement('option');
+				none.value = 0;
+				none.setAttribute('data-i18n', 'ir.cmd.none');
+				none.textContent = i18next.t('ir.cmd.none');
+				if (num === 0) { none.selected = true; known = true; }
+				sel.appendChild(none);
+			}
 			IR_COMMANDS.forEach(function (c) {
 				var opt = document.createElement('option');
 				opt.value = c.cmd;
 				opt.setAttribute('data-i18n', c.key);
 				opt.textContent = i18next.t(c.key);
-				if (Number(cmd) === c.cmd) { opt.selected = true; known = true; }
+				if (num === c.cmd) { opt.selected = true; known = true; }
 				sel.appendChild(opt);
 			});
 			// Preserve an unknown/legacy command value so saving doesn't silently drop it.
-			if (!known && cmd !== null && cmd !== undefined) {
+			if (!known && num !== null && num !== 0) {
 				var keep = document.createElement('option');
-				keep.value = cmd;
-				keep.textContent = 'CMD ' + cmd;
+				keep.value = num;
+				keep.textContent = 'CMD ' + num;
 				keep.selected = true;
 				sel.insertBefore(keep, sel.firstChild);
 			}
 			return sel;
 		}
 
 		// Create one mapping row (<tr>) for the given code (number|null) and command.
-		function irMakeRow(code, cmd) {
+		function irMakeRow(code, cmd, longCmd) {
 			var tr = document.createElement('tr');
 
 			var tdCmd = document.createElement('td');
-			tdCmd.appendChild(irBuildCommandSelect(cmd));
+			tdCmd.appendChild(irBuildCommandSelect(cmd, false));
 			tr.appendChild(tdCmd);
 
+			var tdLong = document.createElement('td');
+			tdLong.appendChild(irBuildCommandSelect(longCmd, true));
+			tr.appendChild(tdLong);
+
 			var tdCode = document.createElement('td');
 			var codeSpan = document.createElement('span');
 			codeSpan.className = 'ir-code font-monospace';
@@ -7995,7 +8018,7 @@ <h5 class="modal-title" data-i18n="tools.nvs.erase.title"></h5>
 			if (!body) { return; }
 			body.innerHTML = '';
 			(map || []).forEach(function (m) {
-				body.appendChild(irMakeRow(m.code, m.cmd));
+				body.appendChild(irMakeRow(m.code, m.cmd, m.longCmd));
 			});
 			irUpdateEmptyHint();
 		}
@@ -8004,7 +8027,7 @@ <h5 class="modal-title" data-i18n="tools.nvs.erase.title"></h5>
 		function addIrRow() {
 			var body = document.getElementById('irMappingBody');
 			if (!body) { return; }
-			var row = irMakeRow(null, IR_COMMANDS[0].cmd);
+			var row = irMakeRow(null, IR_COMMANDS[0].cmd, 0);
 			body.appendChild(row);
 			irUpdateEmptyHint();
 			var codeSpan = row.querySelector('.ir-code');
@@ -8049,10 +8072,11 @@ <h5 class="modal-title" data-i18n="tools.nvs.erase.title"></h5>
 				var code = Number(codeStr);
 				if (seen[code]) { dup = true; }
 				seen[code] = true;
-				map.push({ code: code, cmd: Number(tr.querySelector('.ir-cmd').value) });
+				map.push({ code: code, cmd: Number(tr.querySelector('.ir-cmd').value), longCmd: Number(tr.querySelector('.ir-longcmd').value) });
 			});
 			if (dup) { toaster.warning(i18next.t('ir.duplicate')); }
-			await postSettings({ ir: { map: map } });
+			var longMs = Number(document.getElementById('irLongPressMs').value) || 600;
+			await postSettings({ ir: { map: map, longPressMs: longMs } });
 		}
 
 		var rfidScanCallback = null;

src/IrReceiver.cpp

@@ -18,8 +18,8 @@
 // Debounce timestamp for non-volume actions
 std::atomic<uint32_t> IrReceiver_LastRcCmdTimestamp = 0u;
 
-// Runtime mapping table (IR command -> CMD_* action). Seeded from the compiled-in RC_* defaults,
-// persisted in NVS (key "irMap") and editable via the web UI.
+// Runtime mapping table (IR command -> short/long CMD_* actions). Persisted in NVS (key "irMap2",
+// migrated from the legacy "irMap" layout) and editable via the web UI.
 static IrMapping sMap[IR_MAX_MAPPINGS];
 static uint8_t sMapCount = 0;
 
@@ -28,9 +28,28 @@ static std::atomic<bool> sLearnMode = false;
 static uint32_t sLearnDeadline = 0;
 static constexpr uint32_t IR_LEARN_TIMEOUT = 30000; // ms; matches the web-UI learn modal timeout
 
-static const char *irMapKey = "irMap";
+// Long-press handling. A held IR button keeps re-sending (repeat) frames; once they stop arriving
+// the button is considered released. Buttons that carry a long action fire the short action on
+// release and the long action once the hold passes the (configurable) threshold.
+static constexpr uint16_t IR_LONG_PRESS_DEFAULT = 600; // ms a button must be held for the long action
+static constexpr uint16_t IR_LONG_PRESS_MIN = 200;
+static constexpr uint16_t IR_LONG_PRESS_MAX = 5000;
+static constexpr uint32_t IR_HOLD_RELEASE_MS = 250; // no frame for this long -> button released
+static uint16_t sLongPressMs = IR_LONG_PRESS_DEFAULT;
+
+// State of the button currently being held (only tracked for mappings that have a long action).
+static bool sHoldActive = false;
+static uint8_t sHoldIndex = 0; // index into sMap of the held mapping
+static uint32_t sHoldStartMs = 0; // when the genuine first frame arrived
+static uint32_t sHoldLastFrameMs = 0; // last time a frame for this button was seen
+static bool sHoldLongFired = false; // long action already triggered during this hold
+
+static const char *irMapKey = "irMap2"; // current {code,cmd,longCmd} layout (4 bytes/entry)
+static const char *irLegacyMapKey = "irMap"; // pre-long-press {code,cmd} layout (3 bytes/entry), migration only
+static const char *irLongMsKey = "irLongMs";
 
 static void loadMappings() {
+	sHoldActive = false; // a reload (e.g. after a web save) invalidates any in-flight hold
 	size_t blobLen = gPrefsSettings.getBytesLength(irMapKey);
 	if ((blobLen >= sizeof(IrMapping)) && ((blobLen % sizeof(IrMapping)) == 0)) {
 		uint8_t count = blobLen / sizeof(IrMapping);
@@ -39,13 +58,41 @@ static void loadMappings() {
 		}
 		gPrefsSettings.getBytes(irMapKey, sMap, (size_t) count * sizeof(IrMapping));
 		sMapCount = count;
+	} else if (size_t legacyLen = gPrefsSettings.getBytesLength(irLegacyMapKey); (legacyLen >= 3) && ((legacyLen % 3) == 0)) {
+		// Migrate the legacy 3-byte {code,cmd} layout (pre long-press) so existing remotes survive
+		// the firmware update. Each entry gains longCmd = 0 (no long action). The migrated table is
+		// rewritten under the new key and the old blob is dropped so this runs exactly once.
+		uint8_t count = legacyLen / 3;
+		if (count > IR_MAX_MAPPINGS) {
+			count = IR_MAX_MAPPINGS;
+		}
+		uint8_t legacy[IR_MAX_MAPPINGS * 3];
+		gPrefsSettings.getBytes(irLegacyMapKey, legacy, (size_t) count * 3);
+		for (uint8_t i = 0; i < count; i++) {
+			sMap[i].code = (uint16_t) legacy[i * 3] | ((uint16_t) legacy[i * 3 + 1] << 8);
+			sMap[i].cmd = legacy[i * 3 + 2];
+			sMap[i].longCmd = 0;
+		}
+		sMapCount = count;
+		gPrefsSettings.putBytes(irMapKey, sMap, (size_t) count * sizeof(IrMapping));
+		gPrefsSettings.remove(irLegacyMapKey);
 	} else {
 		// No (valid) mapping stored yet -> start EMPTY: by default the remote does nothing at all.
 		// The user assigns every button explicitly in the web UI. This deliberately drops the old
 		// compiled-in RC_* layout so the upstream sample-remote codes can't accidentally match a
 		// real remote and trigger unwanted actions (e.g. shutdown / Bluetooth toggle).
 		sMapCount = 0;
 	}
+
+	// Long-press threshold (configurable via the web UI), clamped to a sane range.
+	uint32_t ms = gPrefsSettings.getUInt(irLongMsKey, IR_LONG_PRESS_DEFAULT);
+	if (ms < IR_LONG_PRESS_MIN) {
+		ms = IR_LONG_PRESS_MIN;
+	}
+	if (ms > IR_LONG_PRESS_MAX) {
+		ms = IR_LONG_PRESS_MAX;
+	}
+	sLongPressMs = (uint16_t) ms;
 }
 #endif
 
@@ -87,13 +134,31 @@ uint8_t IrReceiver_GetMappings(IrMapping *out, uint8_t maxCount) {
 #endif
 }
 
+uint16_t IrReceiver_GetLongPressMs() {
+#ifdef IR_CONTROL_ENABLE
+	return sLongPressMs;
+#else
+	return 0;
+#endif
+}
+
 void IrReceiver_Cyclic() {
 #ifdef IR_CONTROL_ENABLE
 	// Auto-expire learn mode so a forgotten/aborted learn session can't suppress the remote forever.
 	if (sLearnMode && ((int32_t) (millis() - sLearnDeadline) >= 0)) {
 		sLearnMode = false;
 	}
 
+	// IR has no "button released" event - a held button simply stops sending frames. Once the frames
+	// for a long-press candidate stop arriving, treat it as released: fire the short action unless the
+	// long action already fired while it was held.
+	if (sHoldActive && ((millis() - sHoldLastFrameMs) > IR_HOLD_RELEASE_MS)) {
+		if (!sHoldLongFired) {
+			Cmd_Action(sMap[sHoldIndex].cmd);
+		}
+		sHoldActive = false;
+	}
+
 	if (IrReceiver.decode()) {
 		// Print a short summary of received data (serial-console learning still works as a fallback)
 		IrReceiver.printIRResultShort(&Serial);
@@ -113,24 +178,63 @@ void IrReceiver_Cyclic() {
 			return;
 		}
 
+		// Look up the received command in the runtime mapping table.
+		int16_t mi = -1;
+		for (uint8_t i = 0; i < sMapCount; i++) {
+			if (sMap[i].code == command) {
+				mi = i;
+				break;
+			}
+		}
+
+		// A button with a long action uses hold detection: nothing fires on the first frame, the long
+		// action fires once the hold passes the threshold, the short action fires on release (above).
+		if ((mi >= 0) && (sMap[mi].longCmd != 0)) {
+			if (sHoldActive && (sMap[sHoldIndex].code == command)) {
+				// Still holding the same button.
+				sHoldLastFrameMs = millis();
+				if (!sHoldLongFired && ((millis() - sHoldStartMs) >= sLongPressMs)) {
+					Cmd_Action(sMap[mi].longCmd);
+					sHoldLongFired = true;
+				}
+			} else {
+				// A new button started: finalize the previous candidate's short action first.
+				if (sHoldActive && !sHoldLongFired) {
+					Cmd_Action(sMap[sHoldIndex].cmd);
+				}
+				sHoldActive = true;
+				sHoldIndex = (uint8_t) mi;
+				sHoldStartMs = millis();
+				sHoldLastFrameMs = millis();
+				sHoldLongFired = false;
+			}
+			return;
+		}
+
+		// Plain button (no long action) or unknown code: a different mapped button means any pending
+		// long-press candidate was released, so flush its short action now.
+		if (sHoldActive && (mi >= 0)) {
+			if (!sHoldLongFired) {
+				Cmd_Action(sMap[sHoldIndex].cmd);
+			}
+			sHoldActive = false;
+		}
+
 		bool rcActionOk = false;
 		if (millis() - IrReceiver_LastRcCmdTimestamp >= IR_DEBOUNCE) {
 			rcActionOk = true; // not used for volume up/down
 			IrReceiver_LastRcCmdTimestamp = millis();
 		}
 
-		// Look up the received command in the runtime mapping table and dispatch the mapped action.
-		for (uint8_t i = 0; i < sMapCount; i++) {
-			if (sMap[i].code == command) {
-				const uint8_t cmd = sMap[i].cmd;
-				// Volume up/down fire on every frame (incl. repeats) so holding the button ramps.
-				if ((cmd == CMD_VOLUMEUP) || (cmd == CMD_VOLUMEDOWN)) {
-					Cmd_Action(cmd);
-				} else if (rcActionOk) {
-					Cmd_Action(cmd);
-				}
-				return;
+		if (mi >= 0) {
+			const uint8_t cmd = sMap[mi].cmd;
+			// Volume up/down fire on every frame (incl. repeats) so holding the button ramps.
+			if ((cmd == CMD_VOLUMEUP) || (cmd == CMD_VOLUMEDOWN)) {
+				Cmd_Action(cmd);
+			} else if (rcActionOk) {
+				Cmd_Action(cmd);
 			}
+			return;
 		}
 		if (rcActionOk) {
 			Log_Println("RC: unknown", LOGLEVEL_NOTICE);

src/IrReceiver.h

@@ -5,10 +5,11 @@
 // Maximum number of IR-code -> command mappings kept in RAM / NVS.
 #define IR_MAX_MAPPINGS 32
 
-// One learned remote button: the raw IR command and the CMD_* action it triggers (see values.h).
+// One learned remote button: the raw IR command and the CMD_* actions it triggers (see values.h).
 struct __attribute__((packed)) IrMapping {
 	uint16_t code; // decodedIRData.command of the remote button
-	uint8_t cmd; // CMD_* action to run when this code is received
+	uint8_t cmd; // CMD_* action on a short press (tap)
+	uint8_t longCmd; // CMD_* action on a long press (hold); 0 (CMD_NOTHING) = no long-press action
 };
 
 void IrReceiver_Init();
@@ -18,3 +19,4 @@ void IrReceiver_Cyclic();
 void IrReceiver_ReloadMappings(); // re-read the mapping table from NVS (after a save via the web UI)
 void IrReceiver_SetLearnMode(bool enable); // arm/disarm learn mode (auto-expires after a timeout)
 uint8_t IrReceiver_GetMappings(IrMapping *out, uint8_t maxCount); // copy current table out; returns count
+uint16_t IrReceiver_GetLongPressMs(); // configured long-press threshold in milliseconds