WSPRStation updates

Author: consuelita

.idea/caches/deviceStreaming.xml

@@ -2,6 +2,10 @@ package org.operatorfoundation.audiocoder
 
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
+import org.operatorfoundation.audiocoder.WSPRTimingConstants.AUDIO_CHUNK_DURATION_MILLISECONDS
+import org.operatorfoundation.audiocoder.WSPRTimingConstants.AUDIO_COLLECTION_DURATION_MILLISECONDS
+import org.operatorfoundation.audiocoder.WSPRTimingConstants.AUDIO_COLLECTION_PAUSE_MILLISECONDS
+import org.operatorfoundation.audiocoder.WSPRTimingConstants.CYCLE_INFORMATION_UPDATE_INTERVAL_MILLISECONDS
 import org.operatorfoundation.audiocoder.models.WSPRCycleInformation
 import org.operatorfoundation.audiocoder.models.WSPRDecodeResult
 import org.operatorfoundation.audiocoder.models.WSPRStationConfiguration
@@ -73,7 +77,7 @@ class WSPRStation(
     val stationState: StateFlow<WSPRStationState> = _stationState.asStateFlow()
 
     /**
-     * Most recent decode results.
+     * Most recent WSPR decode results.
      * Updated after each successful decode cycle with all detected signals.
      */
     private val _decodeResults = MutableStateFlow<List<WSPRDecodeResult>>(emptyList())
@@ -187,7 +191,8 @@ class WSPRStation(
      */
     suspend fun requestImmediateDecode(): Result<List<WSPRDecodeResult>>
     {
-        return try {
+        return try
+        {
             if (!timingCoordinator.isCurrentlyInValidDecodeWindow())
             {
                 val nextWindowInfo = timingCoordinator.getTimeUntilNextDecodeWindow()
@@ -292,6 +297,71 @@ class WSPRStation(
         // Phase 2: Collect audio for the required duration
         _stationState.value = WSPRStationState.CollectingAudio
         val audioCollectionStartTime = System.currentTimeMillis()
+
+        while (System.currentTimeMillis() - audioCollectionStartTime < AUDIO_COLLECTION_DURATION_MILLISECONDS)
+        {
+            val audioChunk = audioSource.readAudioChunk(AUDIO_CHUNK_DURATION_MILLISECONDS)
+            signalProcessor.addSamples(audioChunk)
+
+            // Brief pause to prevent excessive CPU usage
+            delay(AUDIO_COLLECTION_PAUSE_MILLISECONDS)
+        }
+
+        // Phase 3: Process collected audio through WSPR decoder
+        _stationState.value = WSPRStationState.ProcessingAudio
+
+        val nativeDecodeResults = signalProcessor.decodeBufferedWSPR(
+            dialFrequencyMHz = configuration.operatingFrequencyMHz,
+            useLowerSideband = configuration.useLowerSidebandMode,
+            useTimeAlignment = configuration.useTimeAlignedDecoding
+        )
+
+        // Phase 4: Convert and store results
+        val processedResults = convertNativeResultsToApplicationFormat(nativeDecodeResults)
+        _decodeResults.value = processedResults
+
+        return processedResults
+    }
+
+    /**
+     * Converts native WSPR decoder results to application-friendly format.
+     *
+     * The native decoder returns WSPRMessage objects with specific field formats.
+     * This method normalizes the data and adds application specific metadata.
+     *
+     * @param nativeResults Raw results from the native WSPR decoder
+     * @return List of processed decode results with consistent formatting
+     */
+    private fun convertNativeResultsToApplicationFormat(nativeResults: Array<WSPRMessage>?): List<WSPRDecodeResult>
+    {
+        if (nativeResults == null) return emptyList()
+
+        return nativeResults.map { nativeMessage ->
+            WSPRDecodeResult(
+                callsign = nativeMessage.call?.trim() ?: WSPRDecodeResult.UNKNOWN_CALLSIGN,
+                gridSquare = nativeMessage.loc?.trim() ?: WSPRDecodeResult.UNKNOWN_GRID_SQUARE,
+                powerLevelDbm = nativeMessage.power,
+                signalToNoiseRatioDb = nativeMessage.snr,
+                frequencyOffsetHz = nativeMessage.freq,
+                completeMessage = nativeMessage.message?.trim() ?: WSPRDecodeResult.EMPTY_MESSAGE,
+                decodeTimestamp = System.currentTimeMillis()
+            )
+        }
+    }
+
+    /**
+     * Starts background updates for cycle information display.
+     * Updates cycle position and timing information every second for UI consumption.
+     */
+    private fun startCycleInformationUpdates()
+    {
+        CoroutineScope(Dispatchers.IO).launch {
+            while (stationOperationJob?.isActive == true)
+            {
+                _cycleInformation.value = timingCoordinator.getCurrentCycleInformation()
+                delay(CYCLE_INFORMATION_UPDATE_INTERVAL_MILLISECONDS)
+            }
+        }
     }
 
 }

AudioCoder/src/main/java/org/operatorfoundation/audiocoder/WSPRStation.kt

@@ -1,10 +1,12 @@
 package org.operatorfoundation.audiocoder
 
 import android.icu.util.Calendar
+import org.operatorfoundation.audiocoder.WSPRTimingConstants.DECODE_START_DELAY_SECONDS
 import org.operatorfoundation.audiocoder.WSPRTimingConstants.DECODE_WINDOW_END_SECOND
 
 import org.operatorfoundation.audiocoder.WSPRTimingConstants.MINUTES_PER_HOUR
 import org.operatorfoundation.audiocoder.WSPRTimingConstants.MINUTES_PER_WSPR_CYCLE
+import org.operatorfoundation.audiocoder.WSPRTimingConstants.SECONDS_PER_MINUTE
 import org.operatorfoundation.audiocoder.models.WSPRCycleInformation
 import org.operatorfoundation.audiocoder.models.WSPRDecodeWindowInformation
 
@@ -106,14 +108,14 @@ class WSPRTimingCoordinator
         val currentSecondInMinute = currentTimeCalendar.get(Calendar.SECOND)
 
         // Cneck if we're in an even minute (transmission window)
-        val isEvenMinute = (currentMinuteInHour % WSPRTimingConstants.MINUTES_PER_WSPR_CYCLE == 0)
+        val isEvenMinute = (currentMinuteInHour % MINUTES_PER_WSPR_CYCLE == 0)
 
         // Calculate position within the current 2-minute WSPR cycle (0-119 seconds)
         val cyclePositionSeconds = calculatePositionInCurrentWSPRCycle(currentMinuteInHour, currentSecondInMinute)
 
         // Check timing constraints within the full 2-minute cycle
-        val isPastDecodeStartDelay = (cyclePositionSeconds >= WSPRTimingConstants.DECODE_START_DELAY_SECONDS)
-        val isBeforeDecodeWindowEnd = (cyclePositionSeconds <= WSPRTimingConstants.DECODE_WINDOW_END_SECOND)
+        val isPastDecodeStartDelay = (cyclePositionSeconds >= DECODE_START_DELAY_SECONDS)
+        val isBeforeDecodeWindowEnd = (cyclePositionSeconds <= DECODE_WINDOW_END_SECOND)
 
         return isEvenMinute && isPastDecodeStartDelay && isBeforeDecodeWindowEnd
     }
@@ -131,8 +133,8 @@ class WSPRTimingCoordinator
      */
     private fun calculatePositionInCurrentWSPRCycle(currentMinute: Int, currentSecond: Int): Int
     {
-        val minuteInCycle = currentMinute % WSPRTimingConstants.MINUTES_PER_WSPR_CYCLE
-        return minuteInCycle * WSPRTimingConstants.SECONDS_PER_MINUTE + currentSecond
+        val minuteInCycle = currentMinute % MINUTES_PER_WSPR_CYCLE
+        return minuteInCycle * SECONDS_PER_MINUTE + currentSecond
     }
 
     /**

AudioCoder/src/main/java/org/operatorfoundation/audiocoder/WSPRTimingCoordinator.kt

@@ -1,6 +1,7 @@
 package org.operatorfoundation.audiocoder.models
 
 import org.operatorfoundation.audiocoder.WSPRTimingConstants
+import org.operatorfoundation.audiocoder.WSPRTimingConstants.WSPR_CYCLE_DURATION_SECONDS
 
 /**
  * Real-time information about the current WSPR cycle state.
@@ -36,6 +37,6 @@ data class WSPRCycleInformation(
     /**
      * Progress through current 2-minute cycle as a percentage (0.0 - 1.0).
      */
-    val currentCyclePercentage: Float
-        get() = cyclePositionSeconds.toFloat() / WSPRTimingConstants.WSPR_CYCLE_DURATION_SECONDS.toFloat()
+    val cycleProgressPercentage: Float
+        get() = cyclePositionSeconds.toFloat() / WSPR_CYCLE_DURATION_SECONDS.toFloat()
 }

AudioCoder/src/main/java/org/operatorfoundation/audiocoder/models/WSPRCycleInformation.kt

@@ -0,0 +1,47 @@
+package org.operatorfoundation.audiocoder.models
+
+/**
+ * Represents the current state of WSPR station operation.
+ * Provides detailed information about what the station is currently doing.
+ */
+sealed class WSPRStationState
+{
+    /** Station is not running */
+    object Stopped : WSPRStationState()
+
+    /** Station is initializing and starting up */
+    object Starting : WSPRStationState()
+
+    /** Station is running and monitoring for decode opportunities */
+    object Running : WSPRStationState()
+
+    /** Station is shutting down */
+    object Stopping : WSPRStationState()
+
+    /**
+     * Station is waiting for the next WSPR decode window to begin.
+     * @param windowInfo Information about the upcoming decode window
+     */
+    data class WaitingForNextWindow(val windowInfo: WSPRDecodeWindowInformation) : WSPRStationState()
+
+    /** Station is preparing to collect audio (clearing buffers, etc.) */
+    object PreparingForCollection : WSPRStationState()
+
+    /** Station is actively collecting audio for decode */
+    object CollectingAudio : WSPRStationState()
+
+    /** Station is processing collected audio through the WSPR decoder */
+    object ProcessingAudio : WSPRStationState()
+
+    /**
+     * Decode cycle completed successfully.
+     * @param decodedSignalCount Number of WSPR signals found in this cycle
+     */
+    data class DecodeCompleted(val decodedSignalCount: Int) : WSPRStationState()
+
+    /**
+     * Station encountered an error and requires attention.
+     * @param errorDescription Human-readable description of the error
+     */
+    data class Error(val errorDescription: String) : WSPRStationState()
+}