unit_MLX90614_data.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_THERMO_UNIT_MLX90614_DATA_HPP
#define M5_UNIT_THERMO_UNIT_MLX90614_DATA_HPP
 
#include <array>
#include <cmath>
#include <cstdint>
#include <limits>  // NaN
 
#include <m5_utility/stl/extension.hpp>
 
namespace m5 {
namespace unit {
 
namespace mlx90614 {
 
enum class Output : uint8_t {
    TA_TO1,         
    TA_TO2,         
    TO2_Undefined,  
    TO1_TO2,        
};
 
enum class IIR : uint8_t {
    Filter50,   
    Filter25,   
    Filter17,   
    Filter13,   
    Filter100,  
    Filter80,   
    Filter67,   
    Filter57,   
};
 
enum class FIR : uint8_t {
    Filter8,     
    Filter16,    
    Filter32,    
    Filter64,    
    Filter128,   
    Filter256,   
    Filter512,   
    Filter1024,  
 
};
 
enum class Gain : uint8_t {
    Coeff1,     
    Coeff3,     
    Coeff6,     
    Coeff12_5,  
    Coeff25,    
    Coeff50,    
    Coeff100,   
    // [7] Coeff100 (duplicate)
};
 
enum class IRSensor : uint8_t {
    Single,  
    Dual     
};
 
struct Data {
    std::array<uint16_t, 3> raw{};  
 
    inline float ambientKelvin() const
    {
        return ((raw[0] & 0x8000) == 0) ? raw[0] * 0.02f : std::numeric_limits<float>::quiet_NaN();
    }
    inline float ambientTemperature() const
    {
        return ambientCelsius();
    }
    inline float ambientCelsius() const
    {
        return ambientKelvin() - 273.15f;
    }
    inline float ambientFahrenheit() const
    {
        return ambientCelsius() * 9.0f / 5.0f + 32.f;
    }
 
    inline float objectKelvin1() const
    {
        return ((raw[1] & 0x8000) == 0) ? raw[1] * 0.02f : std::numeric_limits<float>::quiet_NaN();
    }
    inline float objectTemperature1() const
    {
        return objectCelsius1();
    }
    inline float objectCelsius1() const
    {
        return objectKelvin1() - 273.15f;
    }
    inline float objectFahrenheit1() const
    {
        return objectCelsius1() * 9.0f / 5.0f + 32.f;
    }
 
    inline float objectKelvin2() const
    {
        return ((raw[2] & 0x8000) == 0) ? raw[2] * 0.02f : std::numeric_limits<float>::quiet_NaN();
    }
    inline float objectTemperature2() const
    {
        return objectCelsius2();
    }
    inline float objectCelsius2() const
    {
        return objectKelvin2() - 273.15f;
    }
    inline float objectFahrenheit2() const
    {
        return objectCelsius2() * 9.0f / 5.0f + 32.f;
    }
};
 
struct EEPROM {
    uint16_t toMax{};       
    uint16_t toMin{};       
    uint16_t pwmCtrl{};     
    uint16_t taRange{};     
    uint16_t emissivity{};  
    uint16_t config{};      
    uint16_t addr{};        
    uint16_t id[4]{};       
};
 
struct ConfigRegister {
    inline explicit ConfigRegister(const uint16_t v = 0) : value{v}
    {
    }
    inline IIR iir() const
    {
        return static_cast<IIR>(value & 0x07);
    }
    inline Output output() const
    {
        return static_cast<Output>((value >> 4) & 0x03);
    }
    inline FIR fir() const
    {
        return static_cast<FIR>((value >> 8) & 0x07);
    }
    inline Gain gain() const
    {
        const uint8_t g = (value >> 11) & 0x07;
        return static_cast<Gain>(g > 6 ? 6 : g);
    }
    inline IRSensor irSensor() const
    {
        return static_cast<IRSensor>((value >> 6) & 0x01);
    }
    inline bool positiveKs() const
    {
        return !(value & (1U << 7));
    }
    inline bool positiveKt2() const
    {
        return !(value & (1U << 14));
    }
 
    inline void iir(const IIR iir)
    {
        value = static_cast<uint16_t>((value & ~0x07) | m5::stl::to_underlying(iir));
    }
    inline void output(const Output o)
    {
        value = static_cast<uint16_t>((value & ~(0x03 << 4)) | (m5::stl::to_underlying(o) << 4));
    }
    inline void fir(const FIR fir)
    {
        value = static_cast<uint16_t>((value & ~(0x07 << 8)) | (m5::stl::to_underlying(fir) << 8));
    }
    inline void gain(const Gain gain)
    {
        value = static_cast<uint16_t>((value & ~(0x07 << 11)) | (m5::stl::to_underlying(gain) << 11));
    }
    inline void irSensor(const IRSensor irs)
    {
        value = static_cast<uint16_t>((value & ~(1U << 6)) | (static_cast<unsigned>(m5::stl::to_underlying(irs)) << 6));
    }
    inline void positiveKs(const bool pos)
    {
        value = static_cast<uint16_t>((value & ~(1U << 7)) | (static_cast<unsigned>(!pos) << 7));
    }
    inline void positiveKt2(const bool pos)
    {
        value = static_cast<uint16_t>((value & ~(1U << 14)) | (static_cast<unsigned>(!pos) << 14));
    }
    uint16_t value{};  
};
 
inline float toRaw_to_celsius(const uint16_t t)
{
    return t * 0.01f - 273.15f;
}
 
inline uint16_t celsius_to_toRaw(const float c)
{
    const float v{std::fmax(std::fmin(c, 382.2f), -273.15f)};
    return static_cast<uint16_t>(100 * (v + 0.005f + 273.15f));
}
 
inline float taRaw_to_celsius(const uint8_t t)
{
    return t * 64.0f / 100.f - 38.2f;
}
 
inline uint8_t celsius_to_taRaw(const float c)
{
    const float v{std::fmax(std::fmin(c, 125.f), -38.2f)};
    return static_cast<uint8_t>(100 * (v + 0.32f + 38.2f) / 64.0f);
}
 
inline float raw_to_emissivity(const uint16_t e)
{
    return e / 65535.f;
}
 
inline uint16_t emissivity_to_raw(const float e)
{
    return static_cast<uint16_t>(std::round(65535.f * e));
}
 
}  // namespace mlx90614
 
}  // namespace unit
}  // namespace m5
#endif