DataSaverSPI.h

Go to the documentation of this file.

#ifndef DATASAVERSPI_H
#define DATASAVERSPI_H
 
#include "ArduinoHAL.h"
#include "data_handling/DataPoint.h"
#include "data_handling/DataSaver.h"
#include <array>
#include <cstdlib>
#include <limits>
 
 
constexpr uint32_t kMetadataStartAddress = 0x000000;  // Start writing metadata at the beginning of flash
constexpr uint32_t kDataStartAddress = 0x001000;  // Start writing data after 1 sector (4kB) of metadata
constexpr uint32_t kPostLaunchFlagAddress = 0x000000;  // Address of the post-launch flag
constexpr uint32_t kLaunchStartAddressAddress = 0x000001;  // Address of the launch start address (32 bits)
 
constexpr uint8_t kPostLaunchFlagTrue = 0x00; // Flag to indicate post-launch mode is active
constexpr uint8_t kPostLaunchFlagFalse = 0x01; // Flag to indicate post-launch mode is not active
 
constexpr uint8_t kEmptyPageValue = 0xFF;
 
 
#pragma pack(push, 1)  // Pack the struct to avoid padding between the name and datas
typedef struct { // NOLINT(altera-struct-pack-align)
    uint8_t name;
    float data;
} Record_t; 
 
typedef struct { // NOLINT(altera-struct-pack-align)
    uint8_t name;
    uint32_t timestamp_ms;
} TimestampRecord_t;
#pragma pack(pop)  // Stop packing from here on out

class DataSaverSPI : public IDataSaver {
public:
 
    static constexpr size_t kBufferSize_bytes = 256;

    DataSaverSPI(uint16_t timestampInterval_ms, Adafruit_SPIFlash *flash);

    int saveDataPoint(const DataPoint& dataPoint, uint8_t name) override;

    int saveTimestamp(uint32_t timestamp_ms);

    virtual bool begin() override;

    bool isPostLaunchMode();

    void clearPostLaunchMode();

    void launchDetected(uint32_t launchTimestamp_ms);

    void dumpData(Stream &serial, bool ignoreEmptyPages);

    void clearInternalState();

    void eraseAllData();

    uint32_t getLastTimestamp() const {
        return lastTimestamp_ms_;
    }

    DataPoint getLastDataPoint() const {
        return lastDataPoint_;
    }

    uint32_t getLaunchWriteAddress() const {
        return launchWriteAddress_;
    }

    uint32_t getNextWriteAddress() const {
        return nextWriteAddress_;
    }

    void resetTimestamp() {
        lastTimestamp_ms_ = 0;
    }

    bool quickGetPostLaunchMode() {
        return this->postLaunchMode_;
    }
 
private:
    // Interval at which to store the timestamp in flash.
    uint16_t timestampInterval_ms_;
 
    // The last timestamp we actually wrote to flash.
    uint32_t lastTimestamp_ms_;
 
    // The timestamp this module was given for launch
    uint32_t launchTimestamp_ms_; 
 
    // The last data point written
    DataPoint lastDataPoint_;
 
    // Flash driver
    Adafruit_SPIFlash *flash_;
 
    // Next address in flash at which to write.
    uint32_t nextWriteAddress_;
 
    // Address at which launch was detected
    uint32_t launchWriteAddress_;
 
    bool postLaunchMode_;
 
private:
    bool writeToFlash(const uint8_t* data, size_t length);

    bool readFromFlash(uint32_t& readAddress, uint8_t* buffer, size_t length);
 
    // Write buffer to improve write performance
    uint8_t buffer_[kBufferSize_bytes] = {};
    size_t bufferIndex_ = 0;
    uint32_t bufferFlushes_ = 0; // Keep track of how many times the buffer has been flushed
 
public:
    size_t getBufferIndex() const {
        return bufferIndex_;
    }

    uint32_t getBufferFlushes() const {
        return bufferFlushes_;
    }

    bool getIsChipFullDueToPostLaunchProtection() const {
        return isChipFullDueToPostLaunchProtection_;
    }

    bool getRebootedInPostLaunchMode() const {
        return rebootedInPostLaunchMode_;
    }
 
#ifdef UNIT_TEST
    void setPostLaunchStateForTest(uint32_t nextWriteAddress_in,
                                   uint32_t launchWriteAddress_in,
                                   bool postLaunchMode_in) {
        clearInternalState();
        nextWriteAddress_ = nextWriteAddress_in;
        launchWriteAddress_ = launchWriteAddress_in;
        postLaunchMode_ = postLaunchMode_in;
        isChipFullDueToPostLaunchProtection_ = false;
    }
#endif
 
private:
    uint32_t normalizeDataAddress(uint32_t address) const;

    bool isProtectedLaunchSector(uint32_t sectorNumber) const;

    enum class SectorEraseResult {
        kErased,
        kProtectedSectorLatched,
        kFlashEraseFailed
    };

    SectorEraseResult eraseSectorForWriteAndLatchOnProtection(uint32_t sectorNumber);

    bool shouldStopForPostLaunchWindow();

    int flushBuffer();

    int addDataToBuffer(const uint8_t* data, size_t length);
 
 
    // Overloaded functions to add data to the buffer from a Record_t or TimestampRecord_t
    // More efficient than callling addDataToBuffer with each part of the record
    int addRecordToBuffer(Record_t * record) {
        return addDataToBuffer(reinterpret_cast<const uint8_t*>(record), 5);
    }

    int addRecordToBuffer(TimestampRecord_t * record) {
        return addDataToBuffer(reinterpret_cast<const uint8_t*>(record), 5);
    }
 
    // The chip will keep overwriting data forever unless post launch data is being protected.
    // Once it wraps back around to the launch write address, it will stop writing data.
    bool isChipFullDueToPostLaunchProtection_;
 
    // If the flight computer boots and is already in post launch mode, do not write to flash.
    // Calling clearPostLaunchMode() will allow writing to flash again after a reboot.
    bool rebootedInPostLaunchMode_ = false;
 
    // Tracks which sector has already been pre-erased for the next boundary write.
    // UINT32_MAX means "no prepared sector".
    uint32_t preparedSectorNumber_ = std::numeric_limits<uint32_t>::max();
};
 
#endif // DATA_SAVER_SPI_H