From 226ae7e0c797f6306366e409024aee5b42d3e63c Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 19 Nov 2026 00:05:21 +0000 Subject: [PATCH] JRing heart-rate interval: the vendor's 15/30/45/60 The app sent a fixed 30-minute 0x19 on every connect and after every stream. A ring whose 0x20 reply sets bit 18 (the vendor's condition for its picker) now gets Measurement frequency with 15, 30, 45 or 60 minutes, and the saved value goes out on connect, on Save and after a stream ends. Claude-Session: https://claude.ai/code/session_01P1t1aUqSUPd3whKXmgVm7w --- app/src/main/assets/i18n/pt-BR.json | 1 + .../java/com/pulseloop/ring/JringDriver.kt | 42 +++++++++- .../java/com/pulseloop/ring/RingDecoder.kt | 7 +- .../java/com/pulseloop/ring/RingProtocol.kt | 5 ++ .../ui/screens/SettingsSubScreens.kt | 41 +++++++--- .../ring/JringHeartRateIntervalTest.kt | 67 ++++++++++++++++ .../pulseloop/ring/JringSensorHistoryTest.kt | 5 +- audits/2026-11-19-jring-hr-interval.md | 79 +++++++++++++++++++ docs/jring-56ff-plan.md | 22 ++++++ 9 files changed, 251 insertions(+), 18 deletions(-) create mode 100644 app/src/test/java/com/pulseloop/ring/JringHeartRateIntervalTest.kt create mode 100644 audits/2026-11-19-jring-hr-interval.md diff --git a/app/src/main/assets/i18n/pt-BR.json b/app/src/main/assets/i18n/pt-BR.json index 66d1808b..14c8ec16 100644 --- a/app/src/main/assets/i18n/pt-BR.json +++ b/app/src/main/assets/i18n/pt-BR.json @@ -626,6 +626,7 @@ "EARLIER": "ANTERIORES", "ESTIMATED": "ESTIMADO", "Each night is compared with your own previous four weeks once there are two weeks to compare with. ": "Cada noite é comparada com suas próprias quatro semanas anteriores assim que houver duas semanas para comparar. ", + "Each reading takes about two minutes. A workout you record measures continuously, whatever this is set to.": "Cada leitura leva cerca de dois minutos. Um treino que você grava mede sem parar, qualquer que seja este valor.", "Each ring's typical gap from {0}. Lower is closer.": "A diferença típica de cada anel em relação a {0}. Menor é mais próximo.", "Early bird": "Matutino", "Early evening, when you're under 70% of your step goal. Off in Rest Mode.": "No início da noite, quando você estiver abaixo de 70% da sua meta de passos. Desativado no Modo Descanso.", diff --git a/app/src/main/java/com/pulseloop/ring/JringDriver.kt b/app/src/main/java/com/pulseloop/ring/JringDriver.kt index 9f543457..aa21edfb 100644 --- a/app/src/main/java/com/pulseloop/ring/JringDriver.kt +++ b/app/src/main/java/com/pulseloop/ring/JringDriver.kt @@ -52,7 +52,8 @@ object JringCoordinator : WearableCoordinator { // [bitmapGatedCapabilities] when the 0x20 reply sets the bit (RingDecoder.decodeBandFunction). ) - override val bitmapGatedCapabilities: Set = setOf(WearableCapability.TEMPERATURE) + override val bitmapGatedCapabilities: Set = + setOf(WearableCapability.TEMPERATURE, WearableCapability.MEASUREMENT_INTERVAL) override val iconSystemName = "circle.hexagongrid.circle.fill" @@ -139,7 +140,7 @@ class JringSyncEngine( // 0x19 arms the ring's continuous background sensor logging. The vendor app sends this on // every connect; without it the ring records almost nothing, which is why users previously // had to initialise with the vendor app first. - writer?.enqueue(encoder.makeAutomaticHeartRateCommand(enabled = true, cadenceMinutes = 30)) + writer?.enqueue(automaticHeartRateCommand()) writer?.enqueue(encoder.makeBandFunctionCommand()) // History is paged rather than enqueued: [JringHistorySync] sends one day's 0x10, holds // the rest until that day's stream goes quiet, and asks for each day's 0x16 HR itself. @@ -265,14 +266,33 @@ class JringSyncEngine( val mode = workoutSportMode ?: return stopHeartRate() workoutSportMode = null writer?.enqueue(encoder.makeWorkoutHeartRateStopCommand(mode)) - writer?.enqueue(encoder.makeAutomaticHeartRateCommand(enabled = true, cadenceMinutes = 30)) + writer?.enqueue(automaticHeartRateCommand()) } override fun stopHeartRate() { writer?.enqueue(encoder.makeHeartRateStopCommand()) - writer?.enqueue(encoder.makeAutomaticHeartRateCommand(enabled = true, cadenceMinutes = 30)) + writer?.enqueue(automaticHeartRateCommand()) } + /** The user's saved background schedule, or the vendor's default when none was saved. */ + private var measurementSettings: MeasurementSettings? = null + + override fun setMeasurementSettings(settings: MeasurementSettings?) { + measurementSettings = settings + } + + override fun applyMeasurementSettings(settings: MeasurementSettings) { + measurementSettings = settings + writer?.enqueue(automaticHeartRateCommand()) + } + + /** `0x19` with the saved interval, snapped to the vendor's choices ([JringHeartRateInterval]). + * Sent on connect and again after any live stream, which the ring's schedule yields to. */ + private fun automaticHeartRateCommand(): ByteArray = encoder.makeAutomaticHeartRateCommand( + enabled = measurementSettings?.hrEnabled ?: true, + cadenceMinutes = JringHeartRateInterval.snap(measurementSettings?.hrIntervalMinutes), + ) + /** Spot HR using live HR streaming (0x14), same as workout HR. */ override fun measureHeartRateSpot() { writer?.enqueue(encoder.makeHeartRateStartCommand()) @@ -333,3 +353,17 @@ class JringSyncEngine( return true } } + +/** + * The jring's background heart-rate interval (`0x19` byte 6). The vendor app offers exactly + * 15, 30, 45 and 60 minutes (`HeartrateTestActivity`) and defaults to 30 (`HEARTRATE_SNOOZE_REPEAT`); + * nothing shorter is offered there, so nothing shorter is sent here. + */ +object JringHeartRateInterval { + val CHOICES = listOf(15, 30, 45, 60) + const val DEFAULT = 30 + + /** A saved interval mapped onto the vendor's choices; null (never saved) is the default. */ + fun snap(minutes: Int?): Int = + if (minutes == null || minutes <= 0) DEFAULT else CHOICES.minByOrNull { kotlin.math.abs(it - minutes) }!! +} diff --git a/app/src/main/java/com/pulseloop/ring/RingDecoder.kt b/app/src/main/java/com/pulseloop/ring/RingDecoder.kt index 7065105e..329fdc1d 100644 --- a/app/src/main/java/com/pulseloop/ring/RingDecoder.kt +++ b/app/src/main/java/com/pulseloop/ring/RingDecoder.kt @@ -464,7 +464,12 @@ class RingDecoder(private val clock: JringClock? = null) { val caps = JringBandCapabilities(bytes.copyOfRange(1, bytes.size)) // A unit that sets bit 10 has a temperature log the app can read (0x39), so it gets the // card; the family baseline leaves TEMPERATURE out because most of these rings don't. - val reported = buildSet { if (caps.hasTemperature) add(WearableCapability.TEMPERATURE) } + val reported = buildSet { + if (caps.hasTemperature) add(WearableCapability.TEMPERATURE) + // The vendor's interval picker appears only on rings that set bit 18; the same bit + // opens Measurement frequency here (JringHeartRateInterval). + if (caps.hasAutoHeartRateInterval) add(WearableCapability.MEASUREMENT_INTERVAL) + } return listOfNotNull( RingDecodedEvent.BandFunction(caps), reported.takeIf { it.isNotEmpty() }?.let { RingDecodedEvent.SupportFunctions(it) }, diff --git a/app/src/main/java/com/pulseloop/ring/RingProtocol.kt b/app/src/main/java/com/pulseloop/ring/RingProtocol.kt index 5d789dc7..a84e02f6 100644 --- a/app/src/main/java/com/pulseloop/ring/RingProtocol.kt +++ b/app/src/main/java/com/pulseloop/ring/RingProtocol.kt @@ -81,6 +81,11 @@ data class JringBandCapabilities(val bytes: ByteArray) { val hasTemperature: Boolean get() = bit(10) + /** `FUNCTION_HEART_SHOW_AUTO_INTERVAL` (`DupMainActivity`, zArr[18]): the vendor shows its + * background heart-rate interval picker (15/30/45/60 min, `HeartrateTestActivity`) only when + * the ring sets this bit. */ + val hasAutoHeartRateInterval: Boolean get() = bit(18) + /** SpO₂ uses the dedicated 0x3E command rather than the 0x23 mode selector. */ val separateBloodOxygenMode: Boolean get() = bit(65) val hasOxygenOfflineHistory: Boolean get() = bit(81) diff --git a/app/src/main/java/com/pulseloop/ui/screens/SettingsSubScreens.kt b/app/src/main/java/com/pulseloop/ui/screens/SettingsSubScreens.kt index 6a0036d4..fbdc62d3 100644 --- a/app/src/main/java/com/pulseloop/ui/screens/SettingsSubScreens.kt +++ b/app/src/main/java/com/pulseloop/ui/screens/SettingsSubScreens.kt @@ -1693,7 +1693,8 @@ fun GoalsSettingsScreen(coordinator: RingSyncCoordinator?, onBack: () -> Unit) { /** * Measurement Frequency detail screen: the old inline "Measurement" card (iOS #19 content). - * The hub only shows the row for rings declaring MEASUREMENT_INTERVAL (Colmi). + * The hub only shows the row for rings declaring MEASUREMENT_INTERVAL (Colmi, YCBT, LuckRing, and a jring + * whose 0x20 reply sets bit 18). */ @Composable fun MeasurementSettingsScreen(coordinator: RingSyncCoordinator?, onBack: () -> Unit) { @@ -1710,17 +1711,26 @@ fun MeasurementSettingsScreen(coordinator: RingSyncCoordinator?, onBack: () -> U // [com.pulseloop.ring.YCBTDriver], so its ring can carry the same settings (issue #103, // Albabit's `colmi-smarthealth` unit was capped at 5–60 until 2026-10-23). val isYcbtProtocol = device?.deviceType in setOf(RingDeviceType.YCBT, RingDeviceType.COLMI_SMART_HEALTH) - val minimumInterval = if (isYcbtProtocol) 30 else 5 + // The jring takes the vendor's four choices only (JringHeartRateInterval), and its one + // background command carries heart rate alone: no per-vital switch reaches the wire. + val isJring = device?.deviceType == RingDeviceType.JRING + val minimumInterval = when { + isJring -> com.pulseloop.ring.JringHeartRateInterval.CHOICES.first() + isYcbtProtocol -> 30 + else -> 5 + } + val intervalStep = if (isJring) 15 else 5 + val defaultInterval = if (isJring) com.pulseloop.ring.JringHeartRateInterval.DEFAULT else minimumInterval // 120 min is the only interval beyond the vendor app's own menu (which stops at 60) that is // tested on hardware: the ring ACKed `01 0c 01 78` and read at 10:00 and 12:00 (issue #103, // 2026-10-22). Nothing longer until someone tries it, and YCBT-protocol rings only — it is // not the vendor app's behaviour, it is one ring's. val maximumHrInterval = if (isYcbtProtocol) 120 else 60 - val intervalSteps = ((maximumHrInterval - minimumInterval) / 5 - 1).coerceAtLeast(0) + val intervalSteps = ((maximumHrInterval - minimumInterval) / intervalStep - 1).coerceAtLeast(0) // Only offered where the ring's protocol actually carries a separate blood-oxygen interval — // elsewhere the slider moved, the value saved, and "Saved & sent to ring ✓" appeared over a // setting nothing on the wire could express (issue #66). - val supportsSpo2Interval = device?.deviceType?.supportsSeparateSpo2Interval == true + val supportsSpo2Interval = device?.deviceType?.supportsSeparateSpo2Interval == true && !isJring // The SpO₂ slider runs five minutes lower than the HR one (its floor is "follow heart rate"), // so it needs its own step count: reusing the HR one put ticks 5.45 min apart, none of which // the 5-minute snap could land on. @@ -1730,7 +1740,7 @@ fun MeasurementSettingsScreen(coordinator: RingSyncCoordinator?, onBack: () -> U // only), so a toggle here would be a no-op the ring never sees — the capability bit alone // is not enough to offer it. val supportsStressSetting = WearableCapability.STRESS in capabilities && - !isYcbtProtocol + !isYcbtProtocol && !isJring var cfgHrEnabled by remember { mutableStateOf(true) } var cfgHrInterval by remember { mutableStateOf(5) } @@ -1753,7 +1763,9 @@ fun MeasurementSettingsScreen(coordinator: RingSyncCoordinator?, onBack: () -> U cfgLoaded = false val config = db.deviceMeasurementConfigDao().byDevice(id) cfgHrEnabled = config?.hrEnabled ?: true - cfgHrInterval = (config?.hrIntervalMinutes ?: minimumInterval).coerceIn(minimumInterval, maximumHrInterval) + cfgHrInterval = (config?.hrIntervalMinutes ?: defaultInterval).let { + if (isJring) com.pulseloop.ring.JringHeartRateInterval.snap(it) else it + }.coerceIn(minimumInterval, maximumHrInterval) cfgSpo2 = (config?.spo2Enabled ?: true) && WearableCapability.SPO2 in capabilities cfgSpo2Interval = (config?.spo2IntervalMinutes ?: 0).let { if (it <= 0) 0 else it.coerceIn(minimumInterval, 60) @@ -1807,13 +1819,20 @@ fun MeasurementSettingsScreen(coordinator: RingSyncCoordinator?, onBack: () -> U Slider( enabled = cfgLoaded, value = cfgHrInterval.toFloat(), - onValueChange = { cfgHrInterval = ((it / 5).toInt() * 5).coerceIn(minimumInterval, maximumHrInterval); cfgSavedMsg = null }, + onValueChange = { cfgHrInterval = (kotlin.math.round(it / intervalStep).toInt() * intervalStep).coerceIn(minimumInterval, maximumHrInterval); cfgSavedMsg = null }, valueRange = minimumInterval.toFloat()..maximumHrInterval.toFloat(), steps = intervalSteps, ) } - HorizontalDivider(Modifier.padding(vertical = 8.dp)) - if (WearableCapability.SPO2 in capabilities) { + if (isJring) { + Text( + tr("Each reading takes about two minutes. A workout you record measures continuously, whatever this is set to."), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + if (!isJring) HorizontalDivider(Modifier.padding(vertical = 8.dp)) + if (WearableCapability.SPO2 in capabilities && !isJring) { VitalToggle(tr("Blood oxygen (SpO₂)"), cfgSpo2) { cfgSpo2 = it } // The monitor command takes the same shape for every vital // (`01 {enable, interval}`), so blood oxygen always had an interval — @@ -1891,10 +1910,10 @@ fun MeasurementSettingsScreen(coordinator: RingSyncCoordinator?, onBack: () -> U if (supportsStressSetting) { VitalToggle(tr("Stress"), cfgStress) { cfgStress = it } } - if (WearableCapability.HRV in capabilities) { + if (WearableCapability.HRV in capabilities && !isJring) { VitalToggle("HRV", cfgHrv) { cfgHrv = it } } - if (WearableCapability.TEMPERATURE in capabilities) { + if (WearableCapability.TEMPERATURE in capabilities && !isJring) { VitalToggle(tr("Temperature"), cfgTemp) { cfgTemp = it } } diff --git a/app/src/test/java/com/pulseloop/ring/JringHeartRateIntervalTest.kt b/app/src/test/java/com/pulseloop/ring/JringHeartRateIntervalTest.kt new file mode 100644 index 00000000..aa1fb098 --- /dev/null +++ b/app/src/test/java/com/pulseloop/ring/JringHeartRateIntervalTest.kt @@ -0,0 +1,67 @@ +package com.pulseloop.ring + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +/** The jring's background heart-rate interval: the vendor's 15/30/45/60 choices, gated on bit 18. */ +class JringHeartRateIntervalTest { + private class Recorder : RingCommandWriter { + val sent = mutableListOf() + override fun enqueue(command: ByteArray) { sent += command } + } + + private fun settings(minutes: Int, enabled: Boolean = true) = MeasurementSettings( + hrEnabled = enabled, hrIntervalMinutes = minutes, + spo2Enabled = true, stressEnabled = true, hrvEnabled = true, temperatureEnabled = true, + ) + + private fun cadences(w: Recorder) = w.sent.filter { it[0] == 0x19.toByte() }.map { it[6].toInt() } + + @Test fun snapsToTheVendorChoices() { + assertEquals(30, JringHeartRateInterval.snap(null)) + assertEquals(15, JringHeartRateInterval.snap(5)) + assertEquals(15, JringHeartRateInterval.snap(15)) + assertEquals(45, JringHeartRateInterval.snap(40)) + assertEquals(60, JringHeartRateInterval.snap(120)) + } + + @Test fun neverSavedSendsTheVendorDefault() { + val w = Recorder() + JringSyncEngine(w).runStartup() + assertEquals(listOf(30), cadences(w)) + } + + @Test fun theSavedIntervalGoesOutOnConnectAndOnSave() { + val w = Recorder() + val engine = JringSyncEngine(w) + engine.setMeasurementSettings(settings(15)) + engine.runStartup() + engine.applyMeasurementSettings(settings(45)) + assertEquals(listOf(15, 45), cadences(w)) + } + + @Test fun aStreamEndingRestoresTheSavedInterval() { + val w = Recorder() + val engine = JringSyncEngine(w) + engine.setMeasurementSettings(settings(15)) + engine.stopHeartRate() + assertEquals(listOf(15), cadences(w)) + } + + @Test fun switchedOffClearsTheEnableByte() { + val w = Recorder() + val engine = JringSyncEngine(w) + engine.applyMeasurementSettings(settings(30, enabled = false)) + assertEquals(0, w.sent.single { it[0] == 0x19.toByte() }[5].toInt()) + } + + @Test fun bit18GrantsTheSetting() { + // The owner's ring's 0x20 reply (2026-11-18): payload byte 2 = 0x07, so bit 18 is set. + val reply = "2062ec0738090abebb02001b0000000000000000".chunked(2).map { it.toInt(16).toByte() }.toByteArray() + val caps = JringBandCapabilities(reply.copyOfRange(1, reply.size)) + assertTrue(caps.hasAutoHeartRateInterval) + assertFalse(JringBandCapabilities(ByteArray(19)).hasAutoHeartRateInterval) + } +} diff --git a/app/src/test/java/com/pulseloop/ring/JringSensorHistoryTest.kt b/app/src/test/java/com/pulseloop/ring/JringSensorHistoryTest.kt index d4480eba..e384b7f4 100644 --- a/app/src/test/java/com/pulseloop/ring/JringSensorHistoryTest.kt +++ b/app/src/test/java/com/pulseloop/ring/JringSensorHistoryTest.kt @@ -95,8 +95,9 @@ class JringSensorHistoryTest { val caps = events.filterIsInstance().single().capabilities assertTrue(caps.hasTemperature && caps.hasOxygenOfflineHistory && caps.hasPressureHistory) val granted = events.filterIsInstance().single().capabilities - assertEquals(setOf(WearableCapability.TEMPERATURE), granted) - assertTrue(WearableCapability.TEMPERATURE in JringCoordinator.bitmapGatedCapabilities) + // Bit 18 too: this ring offers the vendor's heart-rate interval picker (JringHeartRateInterval). + assertEquals(setOf(WearableCapability.TEMPERATURE, WearableCapability.MEASUREMENT_INTERVAL), granted) + assertTrue(granted.all { it in JringCoordinator.bitmapGatedCapabilities }) } @Test fun spotMeasurementKeepsItsHrvByte() { diff --git a/audits/2026-11-19-jring-hr-interval.md b/audits/2026-11-19-jring-hr-interval.md new file mode 100644 index 00000000..82887a05 --- /dev/null +++ b/audits/2026-11-19-jring-hr-interval.md @@ -0,0 +1,79 @@ +# Audit: JRing heart-rate interval + +Date: 2026-11-19 · PR: see the PR linking this file · Auditor: Claude Code. +- **impeccable:** applied to the **rendered** Measurement frequency screen for a JRing. It was + drawn on the JVM with Robolectric, under the app theme with the new look on, at 1.0× and 1.3×. + The harness is local only. +- **Device check:** owed. +- **ux-user-flows, graphic-design-fundamentals, less-is-more:** applied by hand. + +## Scope + +The owner asked for a 15-minute option for the JRing's background heart rate. Settings → My ring → +Measurement frequency now appears for a JRing whose capability reply sets bit 18 (the vendor app's +own condition). For a JRing the screen shows: +- the All-day heart rate switch; +- a slider with the vendor's four choices, 15, 30, 45 and 60 minutes; +- one line on what a reading is. + +Nothing changes for other rings. + +## ux-user-flows (§13 flow review checklist) + +- **Entry:** Settings → My ring → Measurement frequency. The row was absent for every JRing until + now. +- **Steps:** pick an interval, then Save. "Saved & sent to ring ✓" when connected, otherwise "Saved — + will sync on next connect" (existing states). +- **States:** + - **Never saved:** shows 30 min, the vendor default and what the app always sent. + - **Saved:** the saved value, snapped to the nearest stop. + - **Switched off:** the slider hides; the ring is told background heart rate is off. + - **A ring without bit 18:** no row; the app keeps sending 30. +- **Exits:** Back without saving changes nothing. + +## impeccable + +### Audit (native, on renders) + +| # | Dimension | Score | Key finding | +|---|---|---|---| +| 1 | Accessibility | 4 | Standard Slider and Switch; the value is also text ("Every 30 min"). | +| 2 | Performance | 4 | No new reads. | +| 3 | Appearance & theming | 4 | Existing card and controls; one 12sp note. | +| 4 | Platform conformance | 4 | Four discrete slider stops, matching the four choices. | +| 5 | Adaptivity | 4 | At 1.3× the note wraps to three lines; nothing clips. | +| | **Total** | **20/20** | | + +### Critique + +| # | Heuristic | Score | Key issue | +|---|---|---|---| +| 1 | Visibility of status | 4 | Value shown above the slider; save confirmation unchanged. | +| 2 | Match real world | 4 | Minutes, as the vendor app shows them. | +| 5 | Error prevention | 4 | Only values the vendor offers can be chosen. | +| 8 | Minimalist | 4 | Switches the ring can't act on are hidden. | +| 10 | Help | 4 | One line: what a reading is, and that workouts measure continuously. | +| | **Total (of the five that apply)** | **20/20** | | + +### Polish + +- [P3] The 5-min Colmi steps and the 15-min JRing steps share one slider component; tick spacing + differs by ring, which is right for each ring. + +No P0 or P1. + +## graphic-design-fundamentals (§13 checklist) + +- **Hierarchy:** title, explainer, switch, value, slider, note, Save. Unchanged order. +- **Colour:** no new colours. +- **Real size:** checked at 411dp, 1.0 and 1.3. + +## less-is-more + +| Element | Verdict | +|---|---| +| SpO₂ / stress / HRV / temperature switches for a JRing | Cut: the ring has no command for them | +| Intervals under 15 min | Left out: the vendor never offers them | +| The note | Kept: answers "why only every 15 min?" and "what about workouts?" | + +No action gained a tap. diff --git a/docs/jring-56ff-plan.md b/docs/jring-56ff-plan.md index 9d903118..139d04c9 100644 --- a/docs/jring-56ff-plan.md +++ b/docs/jring-56ff-plan.md @@ -430,3 +430,25 @@ gitignored `decompiled-jring-offical/`. a second client, re-run the whole startup and broadcast DISCONNECTED. - **Diagnostics:** each start, restart and stop goes to the diagnostics log, with the command jring chose. The next export then says which start was sent and when the ring went quiet. + +## Background heart-rate interval: the vendor's 15/30/45/60 (2026-11-19) + +The owner asked for a 15-minute option after an export showed the ring reading only every +30 minutes in the daytime. That was our own `0x19` (byte 6 = 30), hardcoded on connect and +after every stream. The vendor's `HeartrateTestActivity` offers exactly 15, 30, 45 and 60 minutes +(default `HEARTRATE_SNOOZE_REPEAT` = 30), and shows the picker only when the ring's `0x20` reply +sets bit 18 (`FUNCTION_HEART_SHOW_AUTO_INTERVAL`). + +- Bit 18 grants `MEASUREMENT_INTERVAL` per unit, like bit 10 grants `TEMPERATURE`, so the + Measurement frequency row appears only on rings the vendor would offer it on. The owner's ring + sets it (payload byte 2 = `0x07`). +- The screen offers only the four vendor stops for a jring, and only the heart-rate switch: the ring + has no per-vital opcode, so SpO₂, stress, HRV and temperature switches would reach nothing. +- `JringHeartRateInterval.snap` maps a saved value onto those stops; never saved = 30. The value goes + out on connect, on Save, and after a spot or workout stream ends. +- Observed on the owner's ring before this change: at night it reads every ~15 minutes whatever + `0x19` says, in 2–6 minute runs of 10-second samples; by day it followed the 30-minute setting + with one 2-minute run. +- iOS (saksham2001/PulseLoopiOS) exposes 5–60 minutes and also tightens the interval during a + workout as a backstop to the stream. Not ported: nothing below 15 is offered by the vendor, and + the backstop is a separate change.