Add an update method for fram buffer

Sts1CobcSw/Edu/ProgramStatusHistory.cpp

@@ -4,12 +4,7 @@
 
 namespace sts1cobcsw::edu
 {
-
-sts1cobcsw::fram::RingBuffer<ProgramStatusHistoryEntry, programStatusHistorySize>
-    programStatusHistory =
-        sts1cobcsw::fram::RingBuffer<ProgramStatusHistoryEntry, programStatusHistorySize>(0);
-
-ProgramStatusHistoryClass<programStatusHistorySize> pObject =
+ProgramStatusHistoryClass<programStatusHistorySize> programStatusHistory =
     ProgramStatusHistoryClass<programStatusHistorySize>();
 }
 

Sts1CobcSw/Edu/ProgramStatusHistory.hpp

@@ -1,23 +1,20 @@
 #pragma once
 
-
+// dsafads dfads ieoqzm   dosdafiqo;
 #include <Sts1CobcSw/ProgramId/ProgramId.hpp>
 #include <Sts1CobcSw/Serial/Serial.hpp>
 
 // clang-format off
-#include <cstdint>
+#include <cstdint> //NOLINT(llvm-include-order)
 #include "Sts1CobcSw/Periphery/FramRingBuffer.hpp"
 // ringbuffer.h does not include <cstdint> even though it requires it
 #include <rodos/support/support-libs/ringbuffer.h>
 // clang-format on
 
 #include <bit>
 
-namespace sts1cobcsw
-{
-using fram::RingBuffer;
 
-namespace edu
+namespace sts1cobcsw::edu
 {
 enum class ProgramStatus : std::uint8_t
 {
@@ -39,9 +36,8 @@ struct ProgramStatusHistoryEntry
     ProgramStatus status = ProgramStatus::programRunning;
 };
 
+
 inline constexpr auto programStatusHistorySize = 20;
-// TODO: Use a class that handle the dual storage (or cache) thing
-extern RingBuffer<ProgramStatusHistoryEntry, programStatusHistorySize> programStatusHistory;
 
 template<std::endian endianness>
 [[nodiscard]] auto DeserializeFrom(void const * source, ProgramStatusHistoryEntry * data)
@@ -50,6 +46,12 @@ template<std::endian endianness>
 [[nodiscard]] auto SerializeTo(void * destination, ProgramStatusHistoryEntry const & data)
     -> void *;
 
+template<std::size_t poolSize>
+auto UpdateRingBufferEntry(fram::RingBuffer<ProgramStatusHistoryEntry, poolSize> & ringBuffer,
+                           const std::int32_t startTime,
+                           const ProgramId programId,
+                           const ProgramStatus newStatus) -> bool;
+
 
 template<std::size_t size>
 class ProgramStatusHistoryClass
@@ -69,16 +71,8 @@ class ProgramStatusHistoryClass
     auto Update(ProgramId programId, std::int32_t startTime, ProgramStatus newStatus) -> void
     {
         // Update FRAM ringbuffer
-        // TODO: Make it work, there is no vals_ array in a fram ringbuffer so we need something
-        // else.
-        // for(std::uint32_t i = 0; i < framProgramStatusHistory_.occupiedCnt; ++i)
-        //{
-        //    if(framProgramStatusHistory_.vals[i].startTime == startTime
-        //       and framProgramStatusHistory_.vals[i].programId == programId)
-        //    {
-        //        framProgramStatusHistory_.vals[i].status = newStatus;
-        //    }
-        //}
+        // TODO: Test
+        UpdateRingBufferEntry(framProgramStatusHistory_, startTime, programId, newStatus);
 
         // Update RAM ringbuffer
         for(std::uint32_t i = 0; i < ramProgramStatusHistory_.occupiedCnt; ++i)
@@ -96,10 +90,10 @@ class ProgramStatusHistoryClass
     RODOS::RingBuffer<ProgramStatusHistoryEntry, size> ramProgramStatusHistory_;
 };
 
-extern ProgramStatusHistoryClass<programStatusHistorySize> pObject;
-}
+extern ProgramStatusHistoryClass<programStatusHistorySize> programStatusHistory;
 }
 
+
 namespace sts1cobcsw
 {
 template<>
@@ -108,3 +102,33 @@ inline constexpr std::size_t serialSize<edu::ProgramStatusHistoryEntry> =
                     decltype(edu::ProgramStatusHistoryEntry::startTime),
                     decltype(edu::ProgramStatusHistoryEntry::status)>;
 }
+
+
+namespace sts1cobcsw::edu
+{
+// TODO: Move this into .cpp file
+template<std::size_t poolSize>
+auto UpdateRingBufferEntry(fram::RingBuffer<ProgramStatusHistoryEntry, poolSize> & ringBuffer,
+                           const std::int32_t startTime,
+                           const ProgramId programId,
+                           const ProgramStatus newStatus) -> bool
+{
+    for(std::uint32_t i = 0; i < poolSize; ++i)
+    {
+        auto const address = ringBuffer.startAddress + i * serialSize<ProgramStatusHistoryEntry>;
+        auto readData = fram::ReadFrom<serialSize<ProgramStatusHistoryEntry>>(address, 0);
+        ProgramStatusHistoryEntry data =
+            Deserialize<ProgramStatusHistoryEntry>(std::span(readData));
+
+        if(data.startTime == startTime and data.programId == programId)
+        {
+            fram::WriteTo(address,
+                          Span(Serialize(ProgramStatusHistoryEntry{.programId = data.programId,
+                                                                   .startTime = data.startTime,
+                                                                   .status = newStatus})),
+                          0);
+            return true;
+        }
+    }
+}
+}

Sts1CobcSw/EduListenerThread.cpp

@@ -79,9 +79,10 @@ class EduListenerThread : public RODOS::StaticThread<>
                             // queue thread
                             if(status.exitCode == 0)
                             {
-                                edu::pObject.Update(status.programId,
-                                                    status.startTime,
-                                                    edu::ProgramStatus::programExecutionSucceeded);
+                                edu::programStatusHistory.Update(
+                                    status.programId,
+                                    status.startTime,
+                                    edu::ProgramStatus::programExecutionSucceeded);
                                 // FIXME: Update
                                 // edu::UpdateProgramStatusHistory(
                                 //    status.programId,
@@ -90,9 +91,10 @@ class EduListenerThread : public RODOS::StaticThread<>
                             }
                             else
                             {
-                                edu::pObject.Update(status.programId,
-                                                    status.startTime,
-                                                    edu::ProgramStatus::programExecutionFailed);
+                                edu::programStatusHistory.Update(
+                                    status.programId,
+                                    status.startTime,
+                                    edu::ProgramStatus::programExecutionFailed);
                                 // FIXME: Update
                                 // edu::UpdateProgramStatusHistory(
                                 //    status.programId,
@@ -129,9 +131,10 @@ class EduListenerThread : public RODOS::StaticThread<>
                             }
                             // break;
 
-                            edu::pObject.Update(status.programId,
-                                                status.startTime,
-                                                edu::ProgramStatus::resultFileTransfered);
+                            edu::programStatusHistory.Update(
+                                status.programId,
+                                status.startTime,
+                                edu::ProgramStatus::resultFileTransfered);
                             break;
                         }
                         case edu::StatusType::invalid:

Sts1CobcSw/EduProgramQueueThread.cpp

@@ -142,7 +142,7 @@ class EduProgramQueueThread : public RODOS::StaticThread<stackSize>
             }
             else
             {
-                edu::pObject.Put(
+                edu::programStatusHistory.Put(
                     edu::ProgramStatusHistoryEntry{.programId = programId,
                                                    .startTime = startTime,
                                                    .status = edu::ProgramStatus::programRunning});

Sts1CobcSw/Periphery/FramRingBuffer.hpp

@@ -22,23 +22,23 @@ template<typename T, std::size_t poolSize>
 class RingBuffer
 {
 public:
-    // NOLINTNEXTLINE(*non-private-member-variables-in-classes)
+    // NOLINTBEGIN(*non-private-member-variables-in-classes)
     std::uint64_t writeCnt = 0;
-    // NOLINTNEXTLINE(*non-private-member-variables-in-classes)
     std::uint64_t readCnt = 0;
-    // NOLINTNEXTLINE(*non-private-member-variables-in-classes)
     std::uint32_t occupiedCnt = 0;
+    Address startAddress;
+    // NOLINTEND(*non-private-member-variables-in-classes)
 
-    explicit RingBuffer(Address address) : startAddress_(address)
+    explicit RingBuffer(Address address) : startAddress(address)
     {
     }
 
-    RingBuffer() : startAddress_(0){};
+    RingBuffer() : startAddress(0){};
 
     void Put(T const & newdata)
     {
         currentWrite_ = writeIndex_;
-        auto const address = startAddress_ + writeIndex_ * serialSize<T>;
+        auto const address = startAddress + writeIndex_ * serialSize<T>;
         fram::WriteTo(address, Span(Serialize(newdata)), 0);
         writeIndex_++;
 
@@ -73,7 +73,7 @@ class RingBuffer
             readIndex_ = 0;
         }
 
-        auto const address = startAddress_ + readIndex_ * serialSize<T>;
+        auto const address = startAddress + readIndex_ * serialSize<T>;
         // TODO: Add a real timeout value (spiTimeout in hw tests is 30ms, but for much more data)
         auto readData = fram::ReadFrom<serialSize<T>>(address, 0);
         fromRing = Deserialize<T>(std::span(readData));
@@ -97,7 +97,6 @@ class RingBuffer
     }
 
 private:
-    Address startAddress_;
     std::uint32_t writeIndex_ = 0;
     std::uint32_t readIndex_ = 0;
     std::uint32_t currentWrite_ = UINT32_MAX;

Tests/UnitTests/FramRingBuffer.test.cpp

@@ -136,16 +136,6 @@ TEST_CASE("Simple put and get inlined")
 }
 
 
-namespace sts1cobcsw
-{
-template<>
-constexpr std::size_t serialSize<edu::ProgramStatusHistoryEntry> =
-    totalSerialSize<decltype(edu::ProgramStatusHistoryEntry::programId),
-                    decltype(edu::ProgramStatusHistoryEntry::startTime),
-                    decltype(edu::ProgramStatusHistoryEntry::status)>;
-}
-
-
 namespace sts1cobcsw::edu
 {
 template<std::endian endianness>