Merge pull request #1131 from torlando-tech/feature/rnode-ruhrgebiet-preset

RNode: add Germany Ruhrgebiet preset and raise custom TX power cap to 27 dBm

Author: torlando-tech

app/src/main/java/network/columba/app/data/model/RNodeRegionalPreset.kt

@@ -79,8 +79,21 @@ data class RNodeRegionalPreset(
     val spreadingFactor: Int,
     /** LoRa CR (5-8) */
     val codingRate: Int,
-    /** Transmission power in dBm */
-    val txPower: Int,
+    /**
+     * Transmission power in dBm, or null when the preset carries no explicit
+     * override and the frequency region's default should be kept. Most RNode
+     * radios top out at 17-22 dBm; only the Heltec v4 reaches the higher EU868
+     * sub-band-P ceiling, so presets defer to the region default unless a
+     * board is known to need more. Applied (when non-null) when the preset is
+     * selected; a null value leaves the current / region-default TX power.
+     */
+    val txPower: Int? = null,
+    /**
+     * Long-term airtime limit in percent (1-100), or null when the preset
+     * carries no explicit long-term airtime constraint. Applied to the
+     * `lt_alock` field when the preset is selected.
+     */
+    val longTermAirtimeLimit: Int? = null,
     val description: String,
 )
 
@@ -796,6 +809,18 @@ object RNodeRegionalPresets {
                 txPower = 14,
                 description = "Wiesbaden configuration",
             ),
+            RNodeRegionalPreset(
+                id = "de_ruhrgebiet",
+                countryCode = "DE",
+                countryName = "Germany",
+                cityOrRegion = "Ruhrgebiet",
+                frequency = 869462500,
+                bandwidth = 125000,
+                spreadingFactor = 8,
+                codingRate = 5,
+                longTermAirtimeLimit = 10,
+                description = "Ruhrgebiet configuration (869.4625 MHz, region-default TX, 10% LT airtime)",
+            ),
             // ==================== ITALY ====================
             RNodeRegionalPreset(
                 id = "it_default",

app/src/main/java/network/columba/app/ui/screens/rnode/RegionSelectionStep.kt

@@ -2,6 +2,8 @@ package network.columba.app.ui.screens.rnode
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
@@ -343,6 +345,7 @@ private fun CountryCard(
     }
 }
 
+@OptIn(ExperimentalLayoutApi::class)
 @Composable
 private fun PopularPresetCard(
     preset: RNodeRegionalPreset,
@@ -405,8 +408,9 @@ private fun PopularPresetCard(
             Spacer(Modifier.height(8.dp))
 
             // Settings preview - show all parameters since these are complete presets
-            Row(
+            FlowRow(
                 horizontalArrangement = Arrangement.spacedBy(16.dp),
+                verticalArrangement = Arrangement.spacedBy(4.dp),
             ) {
                 SettingChip(
                     label = "${preset.frequency / 1_000_000.0} MHz",
@@ -420,10 +424,18 @@ private fun PopularPresetCard(
                     label = "${preset.bandwidth / 1000} kHz",
                     isSelected = isSelected,
                 )
-                SettingChip(
-                    label = "${preset.txPower} dBm",
-                    isSelected = isSelected,
-                )
+                preset.txPower?.let { tx ->
+                    SettingChip(
+                        label = "$tx dBm",
+                        isSelected = isSelected,
+                    )
+                }
+                preset.longTermAirtimeLimit?.let { limit ->
+                    SettingChip(
+                        label = "${limit}% LT",
+                        isSelected = isSelected,
+                    )
+                }
             }
         }
     }

app/src/main/java/network/columba/app/ui/screens/rnode/ReviewConfigStep.kt

@@ -398,7 +398,7 @@ fun ReviewConfigStep(viewModel: RNodeWizardViewModel) {
                 Spacer(Modifier.height(8.dp))
 
                 // SF, CR, TX Power row
-                val maxTxPower = regionLimits?.maxTxPower ?: 22
+                val maxTxPower = regionLimits?.maxTxPower ?: 27
 
                 Row(
                     horizontalArrangement = Arrangement.spacedBy(8.dp),

app/src/main/java/network/columba/app/viewmodel/RNodeConfigValidator.kt

@@ -54,7 +54,7 @@ object RNodeConfigValidator {
     private const val MIN_CR = 5
     private const val MAX_CR = 8
     private const val MIN_TX_POWER = 0
-    private const val DEFAULT_MAX_TX_POWER = 22
+    private const val DEFAULT_MAX_TX_POWER = 27
 
     // Default frequency range (when no region is selected)
     private const val DEFAULT_MIN_FREQ = 137_000_000L

app/src/main/java/network/columba/app/viewmodel/RNodeWizardViewModel.kt

@@ -3311,6 +3311,8 @@ class RNodeWizardViewModel
         }
 
         fun selectPreset(preset: RNodeRegionalPreset) {
+            val ltAlock = preset.longTermAirtimeLimit?.toString()
+            val presetTx = preset.txPower?.toString()
             _state.update {
                 it.copy(
                     selectedPreset = preset,
@@ -3324,8 +3326,15 @@ class RNodeWizardViewModel
                     spreadingFactorError = null,
                     codingRate = preset.codingRate.toString(),
                     codingRateError = null,
-                    txPower = preset.txPower.toString(),
-                    txPowerError = null,
+                    // Presets without an explicit TX power keep the current value
+                    // (the region default), since most RNode radios top out at
+                    // 17-22 dBm and only the Heltec v4 reaches the higher
+                    // EU868 sub-band-P ceiling.
+                    txPower = presetTx ?: it.txPower,
+                    txPowerError = if (presetTx != null) null else it.txPowerError,
+                    // Apply the preset's long-term airtime limit if it defines one
+                    ltAlock = ltAlock ?: it.ltAlock,
+                    ltAlockError = if (ltAlock != null) null else it.ltAlockError,
                 )
             }
         }

app/src/test/java/network/columba/app/data/model/RNodeRegionalPresetsTest.kt

@@ -40,6 +40,24 @@ class RNodeRegionalPresetsTest {
         assertTrue("Should include United Kingdom", "United Kingdom" in countries)
     }
 
+    @Test
+    fun `Germany includes the Ruhrgebiet preset with expected values`() {
+        val preset = RNodeRegionalPresets.getPresetsForCountry("Germany")
+            .firstOrNull { it.id == "de_ruhrgebiet" }
+
+        assertNotNull("Ruhrgebiet preset should exist for Germany", preset)
+        assertEquals("Ruhrgebiet", preset!!.cityOrRegion)
+        assertEquals(869_462_500L, preset.frequency)
+        assertEquals(125_000, preset.bandwidth)
+        assertEquals(8, preset.spreadingFactor)
+        assertEquals(5, preset.codingRate)
+        // No explicit TX power: only the Heltec v4 reaches >22 dBm, so the
+        // preset defers to the frequency region's default.
+        assertNull(preset.txPower)
+        // Preset carries the long-term airtime limit applied to lt_alock on selection
+        assertEquals(10, preset.longTermAirtimeLimit)
+    }
+
     // ========== getByCountry Tests ==========
 
     @Test
@@ -217,8 +235,8 @@ class RNodeRegionalPresetsTest {
     fun `all presets have valid TX power`() {
         RNodeRegionalPresets.presets.forEach { preset ->
             assertTrue(
-                "Preset ${preset.id} should have TX power 1-30, got ${preset.txPower}",
-                preset.txPower in 1..30,
+                "Preset ${preset.id} should have TX power 1-30 or none (region default), got ${preset.txPower}",
+                preset.txPower == null || preset.txPower in 1..30,
             )
         }
     }

app/src/test/java/network/columba/app/viewmodel/RNodeConfigValidatorTest.kt

@@ -240,10 +240,10 @@ class RNodeConfigValidatorTest {
 
     @Test
     fun `validateTxPower without region uses default max`() {
-        // Default max is 22
-        val result = RNodeConfigValidator.validateTxPower("25", null)
+        // Default max is 27
+        val result = RNodeConfigValidator.validateTxPower("30", null)
         assertFalse(result.isValid)
-        assertTrue(result.errorMessage!!.contains("22"))
+        assertTrue(result.errorMessage!!.contains("27"))
     }
 
     @Test
@@ -487,7 +487,7 @@ class RNodeConfigValidatorTest {
 
     @Test
     fun `getMaxTxPower returns default without region`() {
-        assertEquals(22, RNodeConfigValidator.getMaxTxPower(null))
+        assertEquals(27, RNodeConfigValidator.getMaxTxPower(null))
     }
 
     @Test

app/src/test/java/network/columba/app/viewmodel/RNodeWizardViewModelTest.kt

@@ -12,6 +12,7 @@ import network.columba.app.data.model.DiscoveredUsbDevice
 import network.columba.app.data.model.FrequencyRegions
 import network.columba.app.data.model.ModemPreset
 import network.columba.app.data.model.RNodeRegionalPreset
+import network.columba.app.data.model.RNodeRegionalPresets
 import network.columba.app.repository.InterfaceRepository
 import network.columba.app.rns.api.model.InterfaceConfig
 import network.columba.app.service.InterfaceConfigManager
@@ -785,6 +786,82 @@ class RNodeWizardViewModelTest {
             }
         }
 
+    @Test
+    fun `selectPreset without explicit tx power keeps region default and applies airtime limit`() =
+        runViewModelTest {
+            advanceUntilIdle()
+
+            viewModel.goToStep(WizardStep.REGION_SELECTION)
+            advanceUntilIdle()
+
+            // EU868 sub-band P defaults to 14 dBm; the preset must not override it.
+            viewModel.selectFrequencyRegion(euRegionP)
+            advanceUntilIdle()
+
+            val preset = RNodeRegionalPresets.presets.first { it.id == "de_ruhrgebiet" }
+            viewModel.selectPreset(preset)
+            advanceUntilIdle()
+
+            val state = viewModel.state.value
+            assertEquals(preset.id, state.selectedPreset?.id)
+            assertEquals("869462500", state.frequency)
+            // No explicit TX power on the preset -> region default (14) is kept.
+            assertNull(preset.txPower)
+            assertEquals(euRegionP.defaultTxPower.toString(), state.txPower)
+            // Preset carries an explicit long-term airtime limit, applied to ltAlock
+            assertEquals("10", state.ltAlock)
+        }
+
+    @Test
+    fun `selectPreset with explicit tx power applies it over the region default`() =
+        runViewModelTest {
+            advanceUntilIdle()
+
+            viewModel.goToStep(WizardStep.REGION_SELECTION)
+            advanceUntilIdle()
+
+            viewModel.selectFrequencyRegion(euRegionP) // default 14 dBm
+            advanceUntilIdle()
+
+            val preset =
+                RNodeRegionalPreset(
+                    id = "test_explicit_tx",
+                    countryCode = "DE",
+                    countryName = "Germany",
+                    cityOrRegion = "Test City",
+                    frequency = 869_462_500,
+                    bandwidth = 125_000,
+                    spreadingFactor = 8,
+                    codingRate = 5,
+                    txPower = 17,
+                    description = "Explicit TX test preset",
+                )
+            viewModel.selectPreset(preset)
+            advanceUntilIdle()
+
+            val state = viewModel.state.value
+            assertEquals("17", state.txPower)
+        }
+
+    @Test
+    fun `selectPreset without airtime limit preserves existing ltAlock`() =
+        runViewModelTest {
+            advanceUntilIdle()
+
+            viewModel.goToStep(WizardStep.REGION_SELECTION)
+            advanceUntilIdle()
+
+            viewModel.updateLtAlock("5")
+            advanceUntilIdle()
+
+            val preset = RNodeRegionalPresets.presets.first { it.id == "us_default" }
+            viewModel.selectPreset(preset)
+            advanceUntilIdle()
+
+            // Preset defines no long-term airtime limit, so the prior value is kept
+            assertEquals("5", viewModel.state.value.ltAlock)
+        }
+
     @Test
     fun `updateStAlock sets error when exceeding duty cycle limit`() =
         runViewModelTest {

rns-api/src/main/java/network/columba/app/rns/api/model/ReticulumConfig.kt

@@ -340,7 +340,7 @@ sealed class InterfaceConfig : Parcelable {
      * @param usbDeviceId Android USB device ID for USB serial mode (required when connectionMode="usb")
      * @param frequency LoRa frequency in Hz (137000000 - 3000000000)
      * @param bandwidth LoRa bandwidth in Hz (7800 - 1625000)
-     * @param txPower Transmission power in dBm (0-22)
+     * @param txPower Transmission power in dBm (0-27)
      * @param spreadingFactor LoRa spreading factor (5-12)
      * @param codingRate LoRa coding rate (5-8)
      * @param stAlock Short-term airtime limit percentage (optional)