Compiler Explorer

Source code

#include <iostream>
#include<cstdint>
#include <array>
#include <cstring>
#include <cassert>
#include <chrono>

//**********  EEPROM configuration ***************************************************
constexpr std::uint32_t eepromWriteCycles = 1'000'000U;
constexpr std::uint32_t eepromPageSize = 32U;
using tSeconds = std::uint32_t;
constexpr tSeconds eepromLifeTime = 3600U * 24U * 365U * 5U; //5 лет

//******************* Dummy NvDriver ****************************************************
using tNvData = std::uint8_t;
using tNvAddress = std::uint32_t;
enum class eNvError
{
    WriteError,
    ReadError,
    Error3,
    Error4,
    Ok
};

volatile std::uint8_t EEPROM[500] = {};

void ShowEEPROM()
{    
    
    for(int i = 0; i < std::size(EEPROM); ++i)
    {   
        std::cout.width(3);
        std::cout << std::dec << std::right <<  static_cast<int>(EEPROM[i]) ;        
        
        if (((i+1) % 16) == 0U)
        {
            std::cout << std::endl;  
        }        
    }
    std::cout << std::endl;
}

struct NvDriver
{
    eNvError Set(const tNvAddress address, const tNvData* const pData, std::size_t size) const
    {
        eNvError returnCode = eNvError::WriteError;
        auto* ptr = pData;
        for(size_t i = 0; i < size; ++i)
        {
            EEPROM[address + i] = *ptr++;            
        }       
        ptr = pData;
        for(size_t i = size; i < size*2U; ++i)
        {
            EEPROM[address + i] = *ptr++;            
        }       
        returnCode = eNvError::Ok;
        return returnCode;
    }

eNvError Get(const tNvAddress address, tNvData* const pData, std::size_t size) const
    {
        eNvError returnCode = eNvError::ReadError;
        auto* ptr = pData;
        for(size_t i = 0; i < size; ++i)
        {
            
            *ptr++ = EEPROM[address + i] ;
        }

std::uint8_t copy[size];
        for(size_t i = size; i < size* 2U; ++i)
        {
            
            copy[i] = EEPROM[address + i] ;
        }
        if (std::memcmp(ptr, copy, size) == 0)
        {
            returnCode = eNvError::Ok;
        }
        return returnCode;
    }
};

//********* Wrapper to unify the return code of any enum **************************
template<typename T>
constexpr std::uint32_t GetOk(const T)
{
    std::uint32_t result = 0U;
    if constexpr (!std::is_same<T,bool>::value)
    {
        result = static_cast<std::uint32_t>(T::Ok);
    }
    return result;
}

class ReturnCode
{
 public:

ReturnCode()  = default;

template<typename T>
    ReturnCode(const T initReturnCode):
        errorValue(static_cast<std::uint32_t>(initReturnCode)),
        goodCode(GetOk(initReturnCode))
    {
        static_assert((std::is_enum<T>::value || std::is_same<T, bool>::value), "The type is not enum or bool") ;
    }

template<class T>
    operator T() const
    {
        //Cast to only enum types
        static_assert((std::is_enum<T>::value || std::is_same<T, bool>::value), "The type is not enum or bool") ;
        return static_cast<T>(errorValue) ;
    }

std::uint32_t GetValue() const
    {
        return errorValue;
    }

operator bool() const
    {
        return (GetValue() != goodCode);
    }

template<class T>
    ReturnCode& operator=(const T returnCode)
    {
        errorValue = static_cast<std::uint32_t>(returnCode);
        goodCode = GetOk(returnCode);
        return *this ;
    }

private:
    std::uint32_t errorValue = 0U ;
    std::uint32_t goodCode = 0U ;
} ;

//******** List for Nv params to calclate the address of concrete EEPROM Param ******
template<const tNvAddress startAddress, typename ...TNvVars>
struct NvVarListBase
{
    static ReturnCode SetToDefault()
    {
        return ( ... || TNvVars::SetToDefault());
    }

static ReturnCode Init()
    {
        return ( ... || TNvVars::Init());
    }
    template<typename T>
    constexpr static size_t GetAddress()
    {        
        return startAddress + GetAddressOffset<T, TNvVars...>();
    }

private:

template <typename QueriedType, typename T, typename ...Ts>
    constexpr static size_t GetAddressOffset()
    {
        auto result = 0;
        if constexpr (!std::is_same<T, QueriedType>::value)
        {
            //можно дописать алгоритм, чтобы все параметры были выравенны по странице.       
            result = T::recordSize * T::recordCounts + GetAddressOffset<QueriedType, Ts...>();            
        }
        return result;
    }
};

//************* NV cashed parameters *************************************************
template<typename NvList, typename T, const T& defaultValue, const auto& nvDriver>
class CachedNvData
{
 public:
    ReturnCode Set(const T& value) const
    {   
        ReturnCode returnCode = eNvError::Ok;
        if (data != value)
        {
          constexpr auto startAddress = GetAddress();             
          returnCode = nvDriver.Set(startAddress, reinterpret_cast<const tNvData*>(&value), sizeof(T));        
          if (!returnCode)
          {
            data = value;            
          }
          std::cout << "Write at address: " << startAddress << std::endl;
        }
        return returnCode;
    }

static ReturnCode Init()
    {   
        constexpr auto startAddress = GetAddress();      
        return nvDriver.Get(startAddress, reinterpret_cast<tNvData*>(&data), sizeof(T));
    }

T Get() const
    {  
        return data;
    }

static ReturnCode SetToDefault()
    {
        constexpr auto startAddress = GetAddress();        
        ReturnCode returnCode = nvDriver.Set(startAddress, reinterpret_cast<const tNvData*>(&defaultValue), sizeof(T));
        return returnCode;
    }
    using Type = T;
    static constexpr size_t recordSize = sizeof(T) * 2U;
    static constexpr size_t recordCounts = 1U;
 private:
   constexpr static auto GetAddress()
   {
     return NvList::template GetAddress<const CachedNvData<NvList, T, defaultValue, nvDriver>>();
   }
    inline static T data = defaultValue;
    
};

//************* NV anti-wear parameters *************************************************
template<typename NvList, typename T, const T& defaultValue, tSeconds updateTime, auto& nvDriver>
class AntiWearNvData
{
 public:
    ReturnCode Set(const T& value) const
    {   
         ReturnCode returnCode = eNvError::Ok;
        if (nvItem.data != value)
        {     
          tAntiWear tempData = {.data = value, .index = nvItem.index};
          // К размеру типа прибавляем 4 байта индекса и умножаем на номер индекса записи.
          // Умножаем на 2, чтобы драйвер мог хранить копиию записи для проверки целостности
          const auto calculatedAddress = GetCalculatedAdress(nvItem.index);
        
          returnCode = nvDriver.Set(calculatedAddress, reinterpret_cast<const tNvData*>(&tempData), sizeof(tAntiWear));        
          //  std::cout << "Write at address: " << calculatedAddress << std::endl;
          //Если запись прошла успешно, то обновляем кэшируемую копию параметра, а также смещаем индекс на 1, для следующей записи
          if (!returnCode)
          {
            nvItem.data = value;          
            //если колчиство записей превысило нужное количество, обнуляем индекс, начинаем писать с начального адреса
            nvItem.index ++;             
          }
        }
        return returnCode;
    }

static ReturnCode Init()
    {   
        const auto ind = FindLastRecordPosition();            
        constexpr auto startAddress = GetAddress();  
        const auto calculatedAddress =  startAddress + recordSize * ind;
        
        return nvDriver.Get(calculatedAddress, reinterpret_cast<tNvData*>(&nvItem), sizeof(tAntiWear));
    }

T Get() const
    {  
        return nvItem.data;
    }

static ReturnCode SetToDefault()
    {
        ReturnCode returnCode = nvDriver.Set(GetCalculatedAdress(nvItem.index), reinterpret_cast<const tNvData*>(&defaultValue), sizeof(T));
        return returnCode;
    }
 private:
   
   static size_t GetCalculatedAdress(std::uint32_t ind)
   {
       constexpr auto startAddress = GetAddress(); 
       size_t result = startAddress + recordSize * ((ind % recordCounts));
       assert(result < std::size(EEPROM));
       return result;
   } 
   static std::uint32_t FindLastRecordPosition()
   {
       // Здесь нужно считать все записи парамтера и найти параметр с самым большим индексом, пока предположим, 
       // что запись с самым большим индексом находится на позиции 1 - Там записано число 15 с индексом 5. 
       return  1U;
   } 
   constexpr static auto GetAddress()
   {
     return NvList::template GetAddress<const AntiWearNvData<NvList, T, defaultValue, updateTime, nvDriver>>();
   }
    
   struct tAntiWear
   {
    T data = defaultValue;     
    std::uint32_t index = 0U;
   };

inline static tAntiWear nvItem;

public:      
      static constexpr auto recordSize = sizeof(nvItem) * 2U; 
      static_assert(eepromPageSize/recordSize != 0, "Too big parameter");
      static constexpr size_t recordCounts =  (eepromPageSize/recordSize) * eepromLifeTime / (eepromWriteCycles * updateTime); 
    
};

//************User code *************************************************************************************************
struct NvVarList;
constexpr NvDriver
nvDriver;

using tString6 = std::array<char, 6U>;

inline constexpr float myFloatDataDefaultValue = 10.0f;
inline constexpr tString6
myStrDefaultValue = { "Popit" };
inline constexpr std::uint32_t
myUint32DefaultValue = 0x30313233;
inline constexpr std::uint16_t myUin16DeafultValue = 0xDEAD;

constexpr CachedNvData<NvVarList, float, myFloatDataDefaultValue, nvDriver> myFloatData;
constexpr CachedNvData<NvVarList, tString6, myStrDefaultValue, nvDriver> myStrData;
constexpr CachedNvData<NvVarList, std::uint32_t, myUint32DefaultValue, nvDriver> myUint32Data;
constexpr AntiWearNvData<NvVarList, std::uint32_t, myUint32DefaultValue, 60U, nvDriver> myUint32AntiWearData;
constexpr AntiWearNvData<NvVarList, float, myFloatDataDefaultValue, 60U, nvDriver> myFloatAntiWearData;

struct SomeSubsystem
{
    static constexpr auto test = CachedNvData < NvVarList, std::uint16_t, myUin16DeafultValue,  nvDriver>();
};

template<const auto& param>
struct SuperSubsystem
{
    void SomeMethod()
    {
        std::cout << "SuperSubsystem read param" << param.Get() << std::endl;
    }
};

//*** Register the Shadowed Nv param in the list *****************************
struct NvVarList : public NvVarListBase<0,
                                        decltype(myStrData),
                                        decltype(myFloatData),
                                        decltype(SomeSubsystem::test),
                                        decltype(myUint32Data),
                                        decltype(myFloatAntiWearData),
                                        decltype(myUint32AntiWearData)
                                        >
{

};

int main()
{
    NvVarList::SetToDefault();
    ReturnCode returnCode = NvVarList::Init();

myFloatData.Set(37.2F);
    myStrData.Set(tString6{"Hello"});

myFloatAntiWearData.Set(10.0F);    
    myFloatAntiWearData.Set(11.0F);    
    myFloatAntiWearData.Set(12.0F);   
    myFloatAntiWearData.Set(13.0F);   
    myFloatAntiWearData.Set(14.0F);   
    
    myUint32AntiWearData.Set(10U);    
    myUint32AntiWearData.Set(11U);    
    myUint32AntiWearData.Set(12U);    
    myUint32AntiWearData.Set(13U);    
    myUint32AntiWearData.Set(14U);    
    myUint32AntiWearData.Set(15U);

ShowEEPROM();
    return 1;
}