diff --git a/CHANGELOG.md b/CHANGELOG.md index b751784..0e2c57f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,12 @@ The application version is maintained in `package.json` and displayed in the adm No changes recorded yet. +## 1.42.4 - 2026-10-25 + +### Added + +- **Decoder clock check.** The decoder's clock is set by hand and doesn't follow summer/winter time. When it is off, lap times stay right (they are the difference of two decoder times), but everything compared with "now" goes wrong: a heat's first lap from the start signal, passes and exercises in the mobile profile. RaceCore never changes the decoder's time; it measures the difference on incoming passings (also during warm-up, before a start) and warns when it is over a minute: Race Day's preflight shows **Decoder clock: 1 h ahead of the computer – set the right time in the decoder**, and the decoder diagnostics under Settings → Connection show the same per decoder. + ## 1.42.3 - 2026-10-25 ### Fixed diff --git a/package-lock.json b/package-lock.json index 41a6cff..299a1a8 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "rc-racecore", - "version": "1.42.3", + "version": "1.42.4", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "rc-racecore", - "version": "1.42.3", + "version": "1.42.4", "hasInstallScript": true, "dependencies": { "better-sqlite3": "^12.11.1", diff --git a/package.json b/package.json index a6fa885..028a3c5 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "rc-racecore", - "version": "1.42.3", + "version": "1.42.4", "private": true, "description": "RC RaceCore live timing and race control with AMMC ingest and SQLite persistence", "engines": { diff --git a/src/app.js b/src/app.js index 0830f96..1fc3617 100644 --- a/src/app.js +++ b/src/app.js @@ -452,6 +452,8 @@ const processDecoderMessage = (msg, decoderRole = "main") => processDecoderMessa triggerRaceAudio, getTrackRecordMs, onTransponderSeen, + // Race Day's preflight shows the decoder clock warning from warm-up passings, before a start. + onDecoderClockChange: () => { if (currentView === "race_day") renderView(); }, }, decoderRole); const renderDashboard = () => renderDashboardView({ addTrackLayout, startPracticeNow, state, dom, t, backend, getActiveSession, getStatusLabel, getSessionTypeLabel, getEventName, getModeLabel, getBackendUrl, formatLap, renderSessionsTable, setCurrentView: (view) => { currentView = view; }, updateViewUrl, renderNav, renderView, connectDecoder, disconnectDecoder, openOverlayWindow, ensureAudioContext, playPassingBeep, playFinishSiren, escapeHtml }); const renderClasses = () => renderClassesView({ state, dom, t, selectedClassEditId: () => selectedClassEditId, setSelectedClassEditId: (value) => { selectedClassEditId = value; }, uid, saveState, renderView, renderTable, escapeHtml, setFormError, bindModalShell }); @@ -809,6 +811,9 @@ const TRANSLATIONS = { "race_day.check_error": "Måste åtgärdas", "race_day.check_session": "Session vald", "race_day.check_backend": "Backend och automatisk backup", + "race_day.check_decoder_clock": "Decoderns klocka", + "race_day.decoder_clock_ahead": "{amount} före datorn – ställ in rätt tid i decodern (sommar-/vintertid?). Första varvet i ett heat och passen i mobilprofilen blir fel.", + "race_day.decoder_clock_behind": "{amount} efter datorn – ställ in rätt tid i decodern (sommar-/vintertid?). Första varvet i ett heat och passen i mobilprofilen blir fel.", "race_day.check_decoder": "Main decoder", "race_day.check_split_decoder": "Mellantidsdecoder", "race_day.check_pit_decoders": "Depådecoders", @@ -2648,6 +2653,9 @@ const TRANSLATIONS = { "race_day.check_error": "Must be fixed", "race_day.check_session": "Session selected", "race_day.check_backend": "Backend and automatic backup", + "race_day.check_decoder_clock": "Decoder clock", + "race_day.decoder_clock_ahead": "{amount} ahead of the computer – set the decoder's clock (summer/winter time?). A heat's first lap and passes in the mobile profile go wrong.", + "race_day.decoder_clock_behind": "{amount} behind the computer – set the decoder's clock (summer/winter time?). A heat's first lap and passes in the mobile profile go wrong.", "race_day.check_decoder": "Main decoder", "race_day.check_split_decoder": "Split decoder", "race_day.check_pit_decoders": "Pit decoders", diff --git a/src/decoder_clock_check.js b/src/decoder_clock_check.js new file mode 100644 index 0000000..072e95e --- /dev/null +++ b/src/decoder_clock_check.js @@ -0,0 +1,37 @@ +// The decoder's clock is the source of truth for timing and is never changed by RaceCore. It +// is set by hand (it doesn't follow summer/winter time), and when it is off, everything that +// compares a passing with "now" goes wrong: a heat's first lap from the start signal, a +// practice pass on the phone, Even laps. Lap times themselves (two decoder times) stay right, +// which is why it goes unnoticed. This only measures how far off it is, to warn about it. +export const DECODER_CLOCK_WARNING_MS = 60 * 1000; +const SAMPLES = 5; + +export function createDecoderClockCheck() { + const samples = new Map(); + return { + // rawTs: the decoder's own time for a passing, receivedAt: the computer's clock on arrival. + record(role, rawTs, receivedAt = Date.now()) { + if (!Number.isFinite(rawTs)) return; + const list = samples.get(role) || []; + list.push(receivedAt - rawTs); + if (list.length > SAMPLES) list.shift(); + samples.set(role, list); + }, + // How far the decoder is behind the computer (ms; negative = ahead), or null before any + // passing. The smallest recent sample: a passing delivered late (resent after a reconnect) + // only makes the decoder look further behind than it is. + skewMs(role) { + const list = samples.get(role); + return list?.length ? Math.min(...list) : null; + }, + }; +} + +// null when the clocks agree; otherwise how far and which way the decoder is off. +export function describeDecoderClockSkew(skewMs) { + if (!Number.isFinite(skewMs) || Math.abs(skewMs) < DECODER_CLOCK_WARNING_MS) return null; + const totalMinutes = Math.round(Math.abs(skewMs) / 60000); + return { ahead: skewMs < 0, hours: Math.floor(totalMinutes / 60), minutes: totalMinutes % 60 }; +} + +export const decoderClockCheck = createDecoderClockCheck(); diff --git a/src/decoder_diagnostics_view.js b/src/decoder_diagnostics_view.js index ed08448..74c1c7a 100644 --- a/src/decoder_diagnostics_view.js +++ b/src/decoder_diagnostics_view.js @@ -1,4 +1,5 @@ import { decoderDiagnostics, DIAGNOSTIC_ROLES } from "./decoder_diagnostics.js"; +import { decoderClockCheck, describeDecoderClockSkew } from "./decoder_clock_check.js"; let stopPrevious = () => {}; export function decoderDiagnosticsMarkup(language) { @@ -63,9 +64,18 @@ export function mountDecoderDiagnostics(root, getSettings) { if (!force && (paused || !root.open)) return; const settings = getSettings(); const entries = decoderDiagnostics.snapshot(); + // The decoder's clock against the computer's, measured on passings (decoder_clock_check.js). + const clockLine = (role) => { + const skew = decoderClockCheck.skewMs(role); + if (skew == null) return `${tr("Decoderklocka", "Decoder clock")}: -`; + const off = describeDecoderClockSkew(skew); + if (!off) return `${tr("Decoderklocka", "Decoder clock")}: ${tr("stämmer med datorn", "matches the computer")}`; + const amount = `${off.hours ? `${off.hours} h ` : ""}${off.minutes ? `${off.minutes} min` : ""}`.trim(); + return `${tr("Decoderklocka", "Decoder clock")}: ${amount} ${off.ahead ? tr("före", "ahead of") : tr("efter", "behind")} ${tr("datorn – ställ in rätt tid i decodern", "the computer – set the right time in the decoder")}`; + }; entries.forEach((entry, i) => { const enabled = i === 0 || (i === 1 ? settings.splitDecoderEnabled : settings.pitDecoderEnabled); - nodes[i].textContent = `${names[i]}: ${enabled ? statuses[entry.status] || entry.status : tr("Avstängd", "Disabled")}\n${tr("Konfigurerad", "Configured")}: ${settings[urlKeys[i]] || "-"}\n${tr("Socket-adress", "Socket address")}: ${entry.url || "-"}\n${tr("Senast ansluten", "Last connected")}: ${date(entry.connectedAt)}\n${tr("Senast mottaget", "Last received")}: ${date(entry.lastReceivedAt)} (${entry.lastReceivedAt == null ? "-" : Math.max(0, Math.floor((Date.now() - entry.lastReceivedAt) / 1000))} s)\nFrames: ${entry.frames} | PASSING: ${entry.passings}\n${tr("Hanterade", "Handled")}: ${entry.handled} | ${tr("Ignorerade", "Ignored")}: ${entry.ignored}\n${tr("Ogiltiga varv", "Invalid laps")}: ${entry.invalid} | JSON ${tr("fel", "errors")}: ${entry.parseErrors}`; + nodes[i].textContent = `${names[i]}: ${enabled ? statuses[entry.status] || entry.status : tr("Avstängd", "Disabled")}\n${tr("Konfigurerad", "Configured")}: ${settings[urlKeys[i]] || "-"}\n${tr("Socket-adress", "Socket address")}: ${entry.url || "-"}\n${tr("Senast ansluten", "Last connected")}: ${date(entry.connectedAt)}\n${tr("Senast mottaget", "Last received")}: ${date(entry.lastReceivedAt)} (${entry.lastReceivedAt == null ? "-" : Math.max(0, Math.floor((Date.now() - entry.lastReceivedAt) / 1000))} s)\nFrames: ${entry.frames} | PASSING: ${entry.passings}\n${tr("Hanterade", "Handled")}: ${entry.handled} | ${tr("Ignorerade", "Ignored")}: ${entry.ignored}\n${tr("Ogiltiga varv", "Invalid laps")}: ${entry.invalid} | JSON ${tr("fel", "errors")}: ${entry.parseErrors}\n${clockLine(entry.role)}`; }); const entry = entries.find(item => item.role === select.value); log.textContent = `${tr("Senaste råmeddelande (max 512 tecken)", "Latest raw frame (max 512 characters)")}:\n${entry.lastFrame || "-"}\n\n${tr("Senaste 50 händelser; orsakskoder", "Latest 50 events; reason codes")}:\n${entry.log.map(item => `${date(item.at)} ${item.reason} ${item.sample}`).join("\n")}`; diff --git a/src/decoder_runtime.js b/src/decoder_runtime.js index a816917..bed1f34 100644 --- a/src/decoder_runtime.js +++ b/src/decoder_runtime.js @@ -4,6 +4,7 @@ import { usesPersonalClock, getLatestClockStartTs } from "./prologue_logic.js"; import { isSuspectLap, getSuspectReferenceLaps } from "./suspect_laps_logic.js"; import { shouldCallPracticePersonalBest } from "./practice_callouts_logic.js"; import { normalizeRaceAudioSettings } from "./race_audio.js"; +import { decoderClockCheck, describeDecoderClockSkew } from "./decoder_clock_check.js"; const PRACTICE_SESSION_TYPES = new Set(["open_practice", "free_practice", "practice"]); // Last personal best *called* per driver, per practice day and layout (practice_callouts_logic.js). @@ -287,6 +288,7 @@ export function processDecoderMessageHelper(msg, deps, decoderRole = "main") { formatLap, announcePassing, saveState, lastOverlayLeaderKeyBySession, lastOverlayTop3BySession, lastOverlayBestLapByKey, triggerRaceAudio = () => {}, getTrackRecordMs = () => null, onTransponderSeen = () => {}, + onDecoderClockChange = () => {}, } = deps; const report = (reason, outcome) => decoderDiagnostics.message(decoderRole, msg, reason, outcome); @@ -309,13 +311,23 @@ export function processDecoderMessageHelper(msg, deps, decoderRole = "main") { if (seenTransponder) onTransponderSeen(seenTransponder); } + // The decoder's clock against the computer's - only measured, never changed: the decoder is + // the source of truth. Before the running-session check so Race Day can warn before a start. + const rtcTs = parseRtcTime(msg.rtc_time); + decoderClockCheck.record(decoderRole, rtcTs); + if (decoderRole === "main" && state.decoder) { + const before = JSON.stringify(describeDecoderClockSkew(state.decoder.clockSkewMs)); + state.decoder.clockSkewMs = decoderClockCheck.skewMs("main"); + if (JSON.stringify(describeDecoderClockSkew(state.decoder.clockSkewMs)) !== before) onDecoderClockChange(); + } + const session = getActiveSession(); if (!session || session.status !== "running") { report("no_running_session"); return; } - const timestamp = parseRtcTime(msg.rtc_time) || Date.now(); + const timestamp = rtcTs || Date.now(); const transponder = String(msg.transponder ?? msg.tran_code ?? "").replace("ID:", "").trim(); if (!transponder) { report("missing_transponder"); diff --git a/src/race_day_logic.js b/src/race_day_logic.js index 9aecfb6..22830a6 100644 --- a/src/race_day_logic.js +++ b/src/race_day_logic.js @@ -1,3 +1,4 @@ +import { describeDecoderClockSkew } from "./decoder_clock_check.js"; import { getLayoutLapWindowOverride } from "./track_layouts_logic.js"; function unique(values) { return [...new Set(values.map((value) => String(value || "").trim()).filter(Boolean))]; @@ -60,6 +61,10 @@ export function buildRaceDayPreflight(state, session, { backendAvailable = false check("backend", backendAvailable ? "ok" : "warning"), check("decoder", state?.decoder?.connected ? "ok" : "error"), ]; + // The decoder's clock against the computer's (decoder_clock_check.js): when it is off, a + // heat's first lap from the start signal and passes on the phone go wrong. + const clockOff = describeDecoderClockSkew(state?.decoder?.clockSkewMs); + if (clockOff) checks.push(check("decoder_clock", "warning", clockOff)); if (state?.settings?.splitDecoderEnabled) { checks.push(check("split_decoder", state?.decoder?.splitConnected ? "ok" : "warning")); diff --git a/src/race_day_view.js b/src/race_day_view.js index f7e3874..1ba478b 100644 --- a/src/race_day_view.js +++ b/src/race_day_view.js @@ -37,6 +37,10 @@ function renderPreflightDetail(item, { t, formatLap, escapeHtml }) { if (item.id === "duplicate_transponders" && item.duplicates?.length) return escapeHtml(item.duplicates.join(", ")); if (item.id === "duplicate_team_members" && item.duplicateTeamMemberNames?.length) return escapeHtml(item.duplicateTeamMemberNames.join(", ")); if (item.id === "transponder_check") return `${item.seen}/${item.total}`; + if (item.id === "decoder_clock") { + const amount = `${item.hours ? `${item.hours} h ` : ""}${item.minutes ? `${item.minutes} min` : ""}`.trim(); + return t(item.ahead ? "race_day.decoder_clock_ahead" : "race_day.decoder_clock_behind", { amount }); + } if (item.id === "grid") return item.notRequired ? t("race_day.not_required") : `${item.count || 0}/${item.expectedCount || 0}`; return t(`race_day.check_${item.level}`); } diff --git a/tests/browser_decoder_clock.js b/tests/browser_decoder_clock.js new file mode 100644 index 0000000..d7d12a9 --- /dev/null +++ b/tests/browser_decoder_clock.js @@ -0,0 +1,48 @@ +import assert from "node:assert/strict"; +import { startFakeDecoder } from "./browser_fake_decoder.js"; + +// The decoder's clock is set by hand and missed the switch to winter time: one hour ahead. +// RaceCore never changes it, but Race Day's preflight and the decoder diagnostics say so - from +// passings before the heat starts (warm-up), so it can be fixed before the first lap counts. +export async function runDecoderClockSmoke({ evaluate, navigate, savedState, waitFor, base }) { + const patchState = async (patch) => { + const current = await savedState(); + Object.assign(current, patch); + const response = await fetch(base + "/api/state", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(current) }); + assert.equal(response.ok, true); + }; + const decoder = await startFakeDecoder(); + const seeded = await savedState(); + await patchState({ + events: [...seeded.events, { id: "dc_event", name: "DC Race", mode: "race", raceConfig: {} }], + sessions: [...seeded.sessions.map((session) => (["running", "paused"].includes(session.status) ? { ...session, status: "finished", endedAt: Date.now() } : session)), { id: "dc_heat", eventId: "dc_event", name: "DC Heat", type: "heat", status: "ready", durationMin: 5 }], + activeSessionId: "dc_heat", + settings: { ...seeded.settings, autoReconnect: true, wsUrl: `ws://127.0.0.1:${decoder.port}` }, + }); + const preflightText = () => evaluate(`document.getElementById("view").innerText`); + try { + await navigate("race_day", "raceDaySessionSelect"); + await waitFor(async () => evaluate('document.getElementById("connectionBadge")?.classList.contains("badge-online")'), "decoder connected"); + assert.doesNotMatch(await preflightText(), /Decoder clock/, "nothing before a passing"); + decoder.sendPassing("8660001", Date.now() + 3600000); + await waitFor(async () => /Decoder clock[\s\S]*1 h ahead of the computer/.test(await preflightText()), "Race Day warns that the decoder is one hour ahead"); + assert.equal((await savedState()).sessions.find((session) => session.id === "dc_heat").status, "ready", "measured during warm-up, nothing started"); + console.log("PASS Race Day warns before the start when the decoder's clock is an hour off (summer/winter time)"); + + await navigate("settings", "settingsForm"); + await evaluate(`document.querySelector('[data-settings-tab="connection"]').click()`); + await evaluate(`(() => { const details = document.getElementById("decoderDiagnostics"); details.open = true; details.dispatchEvent(new Event("toggle")); })()`); + decoder.sendPassing("8660001", Date.now() + 3600000); + await waitFor(async () => /Decoder clock: 1 h ahead of the computer/.test(await evaluate(`document.getElementById("decoderDiagnostics").innerText`)), "the diagnostics show it too"); + console.log("PASS the decoder diagnostics show how far the decoder's clock is off"); + } finally { + const current = await savedState(); + await patchState({ + settings: { ...current.settings, autoReconnect: false }, + sessions: current.sessions.filter((session) => session.id !== "dc_heat"), + events: current.events.filter((event) => event.id !== "dc_event"), + activeSessionId: "", + }); + await decoder.close(); + } +} diff --git a/tests/browser_smoke.js b/tests/browser_smoke.js index abf58dc..8371491 100644 --- a/tests/browser_smoke.js +++ b/tests/browser_smoke.js @@ -15,6 +15,7 @@ import { runPracticeResetSmoke } from "./browser_practice_reset.js"; import { runSuspectLapsSmoke } from "./browser_suspect_laps.js"; import { runOverlayDriverLinkSmoke } from "./browser_overlay_driver_link.js"; import { runProfileClassSmoke } from "./browser_profile_class.js"; +import { runDecoderClockSmoke } from "./browser_decoder_clock.js"; import { runCorrectionsScopeSmoke } from "./browser_corrections_scope.js"; import { runDriversPageSmoke } from "./browser_drivers_page.js"; import { runSeriesSmoke } from "./browser_series.js"; @@ -166,6 +167,7 @@ try { await runPracticeResetSmoke({ evaluate, navigate, savedState, waitFor, base, dialogs }); await runSuspectLapsSmoke({ evaluate, navigate, savedState, waitFor, base, dialogs }); await runOverlayDriverLinkSmoke({ evaluate, navigate, savedState, waitFor, base, send }); + await runDecoderClockSmoke({ evaluate, navigate, savedState, waitFor, base }); await runCorrectionsScopeSmoke({ evaluate, navigate, savedState, waitFor, base }); await runDriversPageSmoke({ evaluate, navigate, savedState, waitFor, base }); await runSeriesSmoke({ evaluate, navigate, savedState, waitFor, base, dialogs }); diff --git a/tests/decoder_clock_check.test.js b/tests/decoder_clock_check.test.js new file mode 100644 index 0000000..0e9aa06 --- /dev/null +++ b/tests/decoder_clock_check.test.js @@ -0,0 +1,31 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { createDecoderClockCheck, describeDecoderClockSkew } from "../src/decoder_clock_check.js"; + +const HOUR = 3600000; + +test("a decoder still on summer time shows as one hour ahead; one in step shows nothing", () => { + const check = createDecoderClockCheck(); + const now = Date.UTC(2026, 9, 25, 17, 21, 0); + check.record("main", now + HOUR + 40, now); // decoder says 19:21, the computer 18:21 + assert.deepEqual(describeDecoderClockSkew(check.skewMs("main")), { ahead: true, hours: 1, minutes: 0 }); + const inStep = createDecoderClockCheck(); + inStep.record("main", now - 30, now); // 30 ms on the network + assert.equal(describeDecoderClockSkew(inStep.skewMs("main")), null); + assert.equal(describeDecoderClockSkew(null), null, "nothing before the first passing"); +}); + +test("a passing delivered late doesn't make the clock look wrong", () => { + const check = createDecoderClockCheck(); + const now = 10 * HOUR; + check.record("main", now - 20, now); + check.record("main", now - 10 * 60000, now + 50); // resent after a reconnect, 10 minutes old + assert.equal(describeDecoderClockSkew(check.skewMs("main")), null); +}); + +test("minutes off are reported as minutes, behind as not ahead", () => { + const check = createDecoderClockCheck(); + check.record("main", 1_000_000, 1_000_000 + 12 * 60000); + assert.deepEqual(describeDecoderClockSkew(check.skewMs("main")), { ahead: false, hours: 0, minutes: 12 }); + assert.equal(check.skewMs("split"), null, "each decoder is measured on its own"); +}); diff --git a/tests/race_day_logic.test.js b/tests/race_day_logic.test.js index 6ed79c3..aaf0a2b 100644 --- a/tests/race_day_logic.test.js +++ b/tests/race_day_logic.test.js @@ -113,3 +113,14 @@ test("preflight shortcuts respect driver, shared-car and team setup", async () = assert.equal(action({ id: "lap_window", level: "warning" }, { mode: "race" }).field, "minLapSec"); assert.equal(action({ id: "decoder", level: "ok" }), null); }); + +test("Race Day preflight warns when the decoder's clock is off, but never blocks the start", () => { + const state = createState(); + state.decoder.clockSkewMs = -3600000 - 40; // the decoder still on summer time: one hour ahead + const result = buildRaceDayPreflight(state, state.sessions[0], { backendAvailable: true }); + const clock = result.checks.find((item) => item.id === "decoder_clock"); + assert.deepEqual({ level: clock.level, ahead: clock.ahead, hours: clock.hours, minutes: clock.minutes }, { level: "warning", ahead: true, hours: 1, minutes: 0 }); + assert.equal(result.ready, true, "a warning: the operator decides"); + state.decoder.clockSkewMs = 25; // network delay only + assert.equal(buildRaceDayPreflight(state, state.sessions[0], { backendAvailable: true }).checks.some((item) => item.id === "decoder_clock"), false); +}); diff --git a/tests/run.js b/tests/run.js index 4ee81e9..331397f 100644 --- a/tests/run.js +++ b/tests/run.js @@ -1,4 +1,5 @@ import "./auth.test.js"; +import "./decoder_clock_check.test.js"; import "./practice_callouts_logic.test.js"; import "./local_cache.test.js"; import "./prologue_logic.test.js";