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>
 
 
#define METADATA_START_ADDRESS 0x000000  // Start writing metadata at the beginning of the flash
#define DATA_START_ADDRESS 0x001000  // Start writing data after 1 sector (4kB) of metadata
#define POST_LAUNCH_FLAG_ADDRESS 0x000000  // Address of the post-launch flag
#define LAUNCH_START_ADDRESS_ADDRESS 0x000001  // Address of the launch start address (32 bits)
 
#define POST_LAUNCH_FLAG_TRUE 0x00 // Flag to indicate post-launch mode is active
#define POST_LAUNCH_FLAG_FALSE 0x01 // Flag to indicate post-launch mode is not active
 
constexpr uint8_t EMPTY_PAGE = 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 BUFFER_SIZE = 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[BUFFER_SIZE] = {};
    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;
    }
 
private:

    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 launchWriteAddress, it will stop writing data.
    bool isChipFullDueToPostLaunchProtection;
 
    // If the fc boots and is already in post launch mode, then do not write to flash
    // calling clearPostLaunchMode() will allow writing to flash again after a reboot
    bool rebootedInPostLaunchMode = false;
};
 
#endif // DATA_SAVER_SPI_H