cs_State.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: May 11, 2015
 * License: LGPLv3+, Apache License 2.0, and/or MIT (triple-licensed)
 */
#pragma once
 
#include <cfg/cs_Boards.h>
#include <common/cs_BaseClass.h>
#include <common/cs_Types.h>
#include <drivers/cs_Storage.h>
#include <drivers/cs_Timer.h>
#include <events/cs_EventListener.h>
#include <protocol/cs_ErrorCodes.h>
 
#include <vector>
 
constexpr const char* operationModeName(OperationMode const& mode) {
    switch (mode) {
        case OperationMode::OPERATION_MODE_SETUP: return "SETUP";
        case OperationMode::OPERATION_MODE_DFU: return "DFU";
        case OperationMode::OPERATION_MODE_FACTORY_RESET: return "RESET";
        case OperationMode::OPERATION_MODE_NORMAL: return "NORMAL";
        case OperationMode::OPERATION_MODE_UNINITIALIZED: return "UNINIT";
    }
    // should never be reached
    return "UNKNOWN";
}
 
constexpr int ValidMode(OperationMode const& mode) {
    switch (mode) {
        case OperationMode::OPERATION_MODE_SETUP:
        case OperationMode::OPERATION_MODE_DFU:
        case OperationMode::OPERATION_MODE_FACTORY_RESET:
        case OperationMode::OPERATION_MODE_NORMAL:
        case OperationMode::OPERATION_MODE_UNINITIALIZED: return 1;
    }
    return 0;
}
 
// TODO: what to do when for invalid operation mode?
// TODO: how can we use TYPIFY() as parameter type?
constexpr OperationMode getOperationMode(uint8_t mode) {
    OperationMode opMode = static_cast<OperationMode>(mode);
    if (ValidMode(opMode)) {
        return opMode;
    }
    return OperationMode::OPERATION_MODE_UNINITIALIZED;
}
 
enum class StateQueueMode { DELAY, THROTTLE };
 
#define FACTORY_RESET_STATE_NORMAL 0
#define FACTORY_RESET_STATE_LOWTX 1
#define FACTORY_RESET_STATE_RESET 2
 
enum StateQueueOp {
    CS_STATE_QUEUE_OP_WRITE,
    CS_STATE_QUEUE_OP_REM_ONE_ID_OF_TYPE,
    CS_STATE_QUEUE_OP_FACTORY_RESET,
    CS_STATE_QUEUE_OP_GC,
};
 
struct __attribute__((__packed__)) cs_state_store_queue_t {
    StateQueueOp operation;
    CS_TYPE type;
    cs_state_id_t id;
    uint32_t counter;  // Uint32, so it can fit 24h.
    uint32_t init_counter;
    bool execute;
};
 
const uint32_t CS_STATE_QUEUE_DELAY_SECONDS_MAX = 0xFFFFFFFF / 1000;
 
struct cs_id_list_t {
    CS_TYPE type;
    std::vector<cs_state_id_t>* ids;
    cs_id_list_t(CS_TYPE type, std::vector<cs_state_id_t>* ids) : type(type), ids(ids) {}
};
 
class State : public BaseClass<>, EventListener {
public:
    static State& getInstance() {
        static State instance;
        return instance;
    }
 
    virtual ~State();
 
    void init(boards_config_t* boardsConfig);
 
    cs_ret_code_t get(cs_state_data_t& data, const PersistenceMode mode = PersistenceMode::STRATEGY1);
 
    cs_ret_code_t get(const CS_TYPE type, void* value, size16_t size);
 
    bool isTrue(CS_TYPE type, const PersistenceMode mode = PersistenceMode::STRATEGY1);
 
    cs_ret_code_t getIds(CS_TYPE type, std::vector<cs_state_id_t>*& ids);
 
    cs_ret_code_t set(const cs_state_data_t& data, PersistenceMode mode = PersistenceMode::STRATEGY1);
 
    cs_ret_code_t set(const CS_TYPE type, void* value, size16_t size);
 
    cs_ret_code_t setDelayed(const cs_state_data_t& data, uint8_t delay);
 
    cs_ret_code_t setThrottled(const cs_state_data_t& data, uint32_t period);
 
    cs_ret_code_t verifySizeForGet(const cs_state_data_t& data);
 
    cs_ret_code_t verifySizeForSet(const cs_state_data_t& data);
 
    cs_ret_code_t remove(
            const CS_TYPE& type, cs_state_id_t id, const PersistenceMode mode = PersistenceMode::STRATEGY1);
 
    void factoryReset();
 
    cs_ret_code_t cleanUp();
 
    cs_ret_code_t getViaPointer(cs_state_data_t& data, const PersistenceMode mode = PersistenceMode::STRATEGY1);
 
    cs_ret_code_t setViaPointer(CS_TYPE type);
 
    void startWritesToFlash();
 
    void handleStorageError(cs_storage_operation_t operation, CS_TYPE type, cs_state_id_t id);
 
    void handleEvent(event_t& event);
 
protected:
    Storage* _storage;
 
    boards_config_t* _boardsConfig;
 
    cs_ret_code_t findInRam(const CS_TYPE& type, cs_state_id_t id, size16_t& index_in_ram);
 
    cs_ret_code_t storeInRam(const cs_state_data_t& data, size16_t& index_in_ram);
 
    cs_ret_code_t storeInRam(const cs_state_data_t& data);
 
    cs_ret_code_t loadFromRam(cs_state_data_t& data);
 
    cs_state_data_t& addToRam(const CS_TYPE& type, cs_state_id_t id, size16_t size);
 
    cs_ret_code_t removeFromRam(const CS_TYPE& type, cs_state_id_t id);
 
    cs_ret_code_t compareWithRam(const cs_state_data_t& data, uint32_t& cmp_result);
 
    cs_ret_code_t storeInFlash(size16_t& index_in_ram);
 
    cs_ret_code_t removeFromFlash(const CS_TYPE& type, const cs_state_id_t id);
 
    cs_ret_code_t addToQueue(
            StateQueueOp operation, const CS_TYPE& type, cs_state_id_t id, uint32_t delayMs, const StateQueueMode mode);
 
    cs_ret_code_t allocate(cs_state_data_t& data);
 
    void delayedStoreTick();
 
    std::vector<cs_state_data_t> _ram_data_register;
 
    std::vector<cs_id_list_t> _idsCache;
 
    std::vector<cs_state_store_queue_t> _store_queue;
 
    bool _startedWritingToFlash  = false;
 
    bool _performingFactoryReset = false;
 
private:
    State();
 
    State(State const&);
 
    void operator=(State const&);
 
    cs_ret_code_t setInternal(const cs_state_data_t& data, PersistenceMode mode);
 
    cs_ret_code_t removeInternal(const CS_TYPE& type, cs_state_id_t id, const PersistenceMode mode);
 
    bool handleFactoryResetResult(cs_ret_code_t retCode);
 
    cs_ret_code_t getDefaultValue(cs_state_data_t& data);
 
    cs_ret_code_t getIdsFromFlash(const CS_TYPE& type, std::vector<cs_state_id_t>*& ids);
 
    cs_ret_code_t addId(const CS_TYPE& type, cs_state_id_t id);
 
    cs_ret_code_t remId(const CS_TYPE& type, cs_state_id_t id);
};