Fix RF module receiving ghost data (#486)

Fixes #485

Author: PatrickKa

Sts1CobcSw/Outcome/Outcome.hpp

@@ -105,6 +105,8 @@ enum class ErrorCode : std::int8_t  // NOLINT
     misaligned,
     eraseFailed,
     programFailed,
+    // RF
+    receivedInvalidData,
 };
 
 

Sts1CobcSw/Outcome/Outcome.ipp

@@ -183,6 +183,9 @@ constexpr auto ToCZString(ErrorCode errorCode) -> char const *
             return "eraseFailed";
         case ErrorCode::programFailed:
             return "programFailed";
+        // RF
+        case ErrorCode::receivedInvalidData:
+            return "receivedInvalidData";
     }
     return "unknown error code";
 }

Sts1CobcSw/Rf/Rf.cpp

@@ -28,6 +28,7 @@
 
 #include <rodos_no_using_namespace.h>
 
+#include <algorithm>
 #include <array>
 #include <bit>
 #include <compare>
@@ -345,7 +346,8 @@ auto ExecuteWithRecovery(Args... args)
             return result.value();
         }
     }
-    // Reset COBC
+    // If all attempts failed, reset the whole COBC
+    DEBUG_PRINT("RF error recovery failed, resetting in %lld s\n", errorHandlingCobcResetDelay / s);
     SuspendFor(errorHandlingCobcResetDelay);
     RODOS::hwResetAndReboot();
     __builtin_unreachable();  // Tell the compiler that hwResetAndReboot() never returns
@@ -429,6 +431,7 @@ auto DoSendAndContinue(std::span<Byte const> data) -> Result<void>
     if(not isInTxMode)
     {
         OUTCOME_TRY(ResetFifos());
+        OUTCOME_TRY(ReadAndClearInterruptStatus());
         DisableRfLatchupProtection();
     }
     auto dataIndex = 0U;
@@ -455,11 +458,21 @@ auto DoSendAndContinue(std::span<Byte const> data) -> Result<void>
         }
         return outcome_v2::success();
     }();
-    OUTCOME_TRY(SetPacketHandlerInterrupts(noInterrupts));
+    // TODO: Refactor
+    auto setInterruptsResult = SetPacketHandlerInterrupts(noInterrupts);
+    auto clearInterruptsResult = ReadAndClearInterruptStatus();
     if(result.has_error())
     {
         return result;
     }
+    if(setInterruptsResult.has_error())
+    {
+        return setInterruptsResult.error();
+    }
+    if(clearInterruptsResult.has_error())
+    {
+        return clearInterruptsResult.error();
+    }
     auto encodedData = convolutionalCoder.Encode(data.subspan(dataIndex), /*flush=*/true);
     OUTCOME_TRY(WriteToFifo(encodedData));
     if(not isInTxMode)
@@ -510,6 +523,7 @@ auto DoReceive(std::span<Byte> data, Duration timeout) -> Result<std::size_t>
             currentDataRate = rxDataRateConfig.dataRate;
         }
         OUTCOME_TRY(ResetFifos());
+        OUTCOME_TRY(ReadAndClearInterruptStatus());
         OUTCOME_TRY(SetPacketHandlerInterrupts(rxFifoAlmostFullInterrupt));
         OUTCOME_TRY(ReadAndClearInterruptStatus());
         DisableRfLatchupProtection();
@@ -528,6 +542,17 @@ auto DoReceive(std::span<Byte> data, Duration timeout) -> Result<std::size_t>
             OUTCOME_TRY(ReadAndClearInterruptStatus());
             ReadFromFifo(data.subspan(dataIndex, rxFifoThreshold));
             dataIndex += rxFifoThreshold;
+            if(dataIndex == rxFifoThreshold)
+            {
+                if(std::ranges::all_of(data.subspan(0, dataIndex),
+                                       [](Byte byte) { return byte == 0xFF_b; }))  // NOLINT
+                {
+                    DEBUG_PRINT("Received bytes are all 0xFF\n");
+                    Reset();
+                    (void)DoInitialize();
+                    return ErrorCode::receivedInvalidData;
+                }
+            }
         }
         auto remainingData = data.subspan(dataIndex);
         OUTCOME_TRY(SetRxFifoThreshold(static_cast<Byte>(remainingData.size())));
@@ -545,14 +570,27 @@ auto DoReceive(std::span<Byte> data, Duration timeout) -> Result<std::size_t>
         dataIndex += remainingData.size();
         return dataIndex;
     }();
+    // TODO: Refactor
     auto setInterruptsResult = SetPacketHandlerInterrupts(noInterrupts);
-    OUTCOME_TRY(DoEnterStandbyMode());
+    auto clearInterruptsResult = ReadAndClearInterruptStatus();
+    auto enterStandbyResult = DoEnterStandbyMode();
+    if(result.has_error())
+    {
+        return result.error();
+    }
     if(setInterruptsResult.has_error())
     {
         return setInterruptsResult.error();
     }
-    OUTCOME_TRY(ReadAndClearInterruptStatus());
-    return result;
+    if(clearInterruptsResult.has_error())
+    {
+        return clearInterruptsResult.error();
+    }
+    if(enterStandbyResult.has_error())
+    {
+        return enterStandbyResult.error();
+    }
+    return result.value();
 }