int address = 0;
float val1 = 123.456f;
byte val2 = 64;
char name[10] = "Arduino";
EEPROM.put(address, val1);
address += sizeof(val1); //+4
EEPROM.put(address, val2);
address += sizeof(val2); //+1
EEPROM.put(address, name);
address += sizeof(name); //+10

//Записываем 10.0F в EEPROM по адресу, где лежит myEEPROMData параметр
myEEPROMData = 10.0F;

//Записываем в EEPROM строку из 5 символов по адресу параметра myStrData
auto returnStatus = myStrData.Set(tStr6{"Hello"});
if (!returnStatus)
{
  std::cout << "Ok"
}
//Записываем в EEPROM float параметр по адресу параметра myFloatData
returnStatus = myFloatData.Set(37.2F);

//Длина параметра 6 байт
constexpr CachedNvData<NvVarList, tString6, myStrDefaultValue,  nvDriver> myStrData;
//Длина параметра 4 байта
constexpr CachedNvData<NvVarList, float, myFloatDataDefaultValue, nvDriver> myFloatData;
//Длина параметра 4 байт
constexpr CachedNvData<NvVarList, std::uint32_t, myUint32DefaultValue,  nvDriver> myUint32Data;

NvVarList<100U, myStrData, myFloatData, myUint32Data>

template<typename NvList, typename T, const T& defaultValue, const auto& nvDriver>
class CaсhedNvData
{
  public:
    ReturnCode Set(T value) const
    {
      //Ищем адрес EEPROM параметра в списке
      constexpr auto address =
                NvList::template GetAddress<NvList,T,defaultValue,nvDriver>();
      //Записываем новое значение в EEPROM
      ReturnCode returnCode = nvDriver.Set(
                                address,
                                reinterpret_cast<const tNvData*>(&value), sizeof(T));
      //Если значение записалось успешно, обновляем копию в ОЗУ
      if (!returnCode)
      {
        memcpy((void*)&data, (void*)&value, sizeof(T));
      }
      return returnCode;
    }
    ReturnCode Init() const
    {
      constexpr auto address =
                NvList::template GetAddress<NvList,T,defaultValue,nvDriver>();
      //Читаем значение из EEPROM
      ReturnCode returnCode = nvDriver.Get(
                                address,
                                reinterpret_cast<tNvData*>(&data), sizeof(T));
      //Tесли значение не прочиталось из EEPROM, устанавливаем значение по умолчанию
      if (returnCode)
      {
        data = defaultValue;
      }
      return returnCode;
    }
    T Get() const
    {
      return data;
    }
    using Type = T;
  private:
    inline static T data = defaultValue;
};

template<const tNvAddress startAddress, const auto& ...nvVars>
struct NvVarListBase
{
    template<typename NvList, typename T, const T& defaultValue, const auto& nvDriver>
    constexpr static size_t GetAddress()
    {
      //Ищем EEPROM адрес параметра с типом
      //CaсhedNvData<NvList, T, defaultValue, nvDriver>
      using tQueriedType = CaсhedNvData<NvList, T, defaultValue, nvDriver>;
      return startAddress +
            GetAddressOffset<tQueriedType>(NvVarListBase<startAddress,nvVars...>());
    }
  private:
   template <typename QueriedType, const auto& arg, const auto&... args>
   constexpr static size_t GetAddressOffset(NvVarListBase<startAddress, arg, args...>)
   {
    //Чтобы узнать тип первого аргумента в списке,
    //создаем объект такого же типа как и первый аргумент
    auto test = arg;
    //если тип созданного объекта такой же как и искомый, то заканчиваем итерации
    if constexpr (std::is_same<decltype(test), QueriedType>::value)
    {
        return  0U;
    } else
    {
      //Иначе увеличиваем адрес на размер типа параметра и переходим к
      //следующему параметру в списке.
        return sizeof(typename decltype(test)::Type) +
                GetAddressOffset<QueriedType>(NvVarListBase<startAddress, args...>());
    }
  }
};

using tString6 = std::array<char, 6U>;
inline constexpr float myFloatDataDefaultValue = 10.0f;
inline constexpr tString6 myStrDefaultValue = {"Habr "};
inline constexpr std::uint32_t myUint32DefaultValue = 0x30313233;

//поскольку список ссылается на параметры, а параметры на список.
//Используем forward declaration
struct NvVarList;
constexpr NvDriver nvDriver;
//Теперь можем использовать NvVarList в шаблоне EEPROM параметров
constexpr CaсhedNvData<NvVarList, float, myFloatDataDefaultValue, nvDriver> myFloatData;
constexpr CaсhedNvData<NvVarList, tString6, myStrDefaultValue,  nvDriver> myStrData;
constexpr CaсhedNvData<NvVarList, uint32_t, myUint32DefaultValue,  nvDriver> myUint32Data;

struct NvVarList : public NvVarListBase<0, myStrData, myFloatData, myUint32Data>
{
};

struct NvVarList;
constexpr NvDriver nvDriver;
using tString6 = std::array<char, 6U>;
inline constexpr float myFloatDataDefaultValue = 10.0f;
inline constexpr tString6 myStrDefaultValue = {"Habr "};
inline constexpr uint32_t myUint32DefaultValue = 0x30313233;
constexpr CaсhedNvData<NvVarList, float, myFloatDataDefaultValue, nvDriver> myFloatData;
constexpr CaсhedNvData<NvVarList, tString6, myStrDefaultValue,  nvDriver> myStrData;
constexpr CaсhedNvData<NvVarList, uint32_t, myUint32DefaultValue,  nvDriver> myUint32Data;
struct NvVarList : public NvVarListBase<0, myStrData, myFloatData, myUint32Data>
{
};
int main()
{
    myStrData.Init();
    myFloatData.Init();
    myUint32Data.Init()
    myStrData.Get();
    returnCode = myStrData.Set(tString6{"Hello"});
    if (!returnCode)
    {
        std::cout << "Hello has been written" << std::endl;
    }
    myStrData.Get();
    myFloatData.Set(37.2F);
    myUint32Data.Set(0x30313233);
    return 1;
}

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