Added simple logger

include/sta/utils/logger.tpp

@@ -0,0 +1,100 @@
+#ifndef STA_UTILS_LOGGER_TPP
+#define STA_UTILS_LOGGER_TPP
+
+#include <sta/debug/debug.hpp>
+#include <sta/drivers/w25qxx.hpp>
+
+namespace sta
+{
+    template <typename T>
+    Logger<T>::Logger(W25Qxx * flash, uint32_t startSec, uint32_t endSec)
+        : flash_{flash},
+          start_{startSec},
+          end_{endSec},
+          address_{start_ * W25QXX_SECTOR_SIZE},
+          buffer_{0x00, },
+          ptr_ {0}
+    {
+        STA_ASSERT(flash != nullptr);
+        STA_ASSERT(endAddr > startAddr);
+    }
+
+    template <typename T>
+    void Logger<T>::write(T data)
+    {
+        uint8_t * bytes = (uint8_t*)(&data);
+        uint8_t length = sizeof(data);
+
+        // Bytes remaining until the page is full.
+        uint8_t remaining = W25QXX_PAGE_SIZE - ptr_;
+
+        // If the written data exceeds the remaining bytes in the page.
+        if (ptr_ + length >= W25QXX_PAGE_SIZE)
+        {
+            std::memcpy(buffer_ + ptr_, bytes, remaining);
+            flash_->pageProgram(address_, buffer_, W25QXX_PAGE_SIZE);
+
+            bytes += remaining;
+            length -= remaining;
+            ptr_ = 0;
+
+            address_ += W25QXX_PAGE_SIZE;
+
+            // If a new sector was started, erase the new sector.
+            if (address_ % W25QXX_SECTOR_SIZE == 0)
+            {
+                // If the size of the logger segment was exceeded, restart at the first sector.
+                if (address_ / W25QXX_SECTOR_SIZE == end_)
+                {
+                    address_ = start_ * W25QXX_SECTOR_SIZE;
+                }
+
+                flash_->sectorErase(address_);
+            }
+        }
+
+        std::memcpy(buffer_ + ptr_, bytes, length);
+    }
+
+    template <typename T>
+    void Logger<T>::clear()
+    {
+        address_ = start_ * W25QXX_SECTOR_SIZE; 
+        ptr_ = 0;
+
+        for (uint32_t i = 0; i < end_ - start_; i++)
+        {
+            flash_->sectorErase((start_ + i) * W25QXX_SECTOR_SIZE);
+        }
+    }
+
+    template <typename T>
+    size_t Logger<T>::occupied()
+    {
+        return (address_ - start_ * W25QXX_SECTOR_SIZE) / sizeof(T);
+    }
+
+    template <typename T>
+    size_t Logger<T>::remaining()
+    {
+        return (end_  * W25QXX_SECTOR_SIZE - address_) / sizeof(T);
+    }
+
+    template <typename T>
+    size_t Logger<T>::length()
+    {
+        return (end_ - start_) * W25QXX_SECTOR_SIZE / sizeof(T);
+    }
+
+    template <typename T>
+    const T& Logger<T>::operator[](std::size_t idx)
+    {
+        uint32_t address = start_ * W25QXX_SECTOR_SIZE + idx * sizeof(T);
+        uint8_t buffer[sizeof(T)];
+        flash_->readData(address, buffer, sizeof(T));
+
+        return *((T*)buffer);
+    }
+} // namespace sta
+
+#endif // STA_UTILS_LOGGER_TPP