unit_MLX90614.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_HPP
#define M5_UNIT_THERMO_UNIT_MLX90614_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <limits>  // NaN
#include <array>
 
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,   
};
 
enum class IRSensor : uint8_t {
    Single,  
    Dual     
};
 
struct Data {
    std::array<uint16_t, 3> raw{};  // linearized raw [0]:Ambient [1]:Object1 [2]:Object2
 
    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{}, toMin{},  
        pwmCtrl{},              
        taRange{},              
        emissivity{},           
        config{},               
        addr{},                 
        id[4]{};                
};
 
}  // namespace mlx90614
 
class UnitMLX90614 : public Component, public PeriodicMeasurementAdapter<UnitMLX90614, mlx90614::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitMLX90614, 0x5A);
 
public:
    struct config_t {
        bool start_periodic{true};
        mlx90614::IIR iir{mlx90614::IIR::Filter100};
        mlx90614::FIR fir{mlx90614::FIR::Filter1024};
        mlx90614::Gain gain{mlx90614::Gain::Coeff12_5};
        mlx90614::IRSensor irs{mlx90614::IRSensor::Single};
        float emissivity{1.0f};
    };
 
    explicit UnitMLX90614(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<mlx90614::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 100 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitMLX90614()
    {
    }
 
    virtual bool begin() override;
    virtual void update(const bool force = false) override;
 
 
    inline config_t config()
    {
        return _cfg;
    }
    inline void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
    const mlx90614::EEPROM& eeprom() const
    {
        return _eeprom;
    }
 
    inline float ambientKelvin() const
    {
        return !empty() ? oldest().ambientKelvin() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float ambientTemperature() const
    {
        return !empty() ? oldest().ambientTemperature() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float ambientCelsius() const
    {
        return !empty() ? oldest().ambientCelsius() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float ambientFahrenheit() const
    {
        return !empty() ? oldest().ambientFahrenheit() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float objectKelvin1() const
    {
        return !empty() ? oldest().objectKelvin1() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float objectTemperature1() const
    {
        return !empty() ? oldest().objectTemperature1() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float objectCelsius1() const
    {
        return !empty() ? oldest().objectCelsius1() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float objectFahrenheit1() const
    {
        return !empty() ? oldest().objectFahrenheit1() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float objectKelvin2() const
    {
        return !empty() ? oldest().objectKelvin2() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float objectTemperature2() const
    {
        return !empty() ? oldest().objectTemperature2() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float objectCelsius2() const
    {
        return !empty() ? oldest().objectCelsius2() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float objectFahrenheit2() const
    {
        return !empty() ? oldest().objectFahrenheit2() : std::numeric_limits<float>::quiet_NaN();
    }
 
 
    inline bool startPeriodicMeasurement(const mlx90614::IIR iir, const mlx90614::FIR fir, const mlx90614::Gain gain,
                                         const mlx90614::IRSensor irs)
    {
        return PeriodicMeasurementAdapter<UnitMLX90614, mlx90614::Data>::startPeriodicMeasurement(iir, fir, gain, irs);
    }
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitMLX90614, mlx90614::Data>::startPeriodicMeasurement();
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitMLX90614, mlx90614::Data>::stopPeriodicMeasurement();
    }
 
 
    bool readConfig(uint16_t& v);
    bool writeConfig(const uint16_t v, const bool apply = true);
    bool readOutput(mlx90614::Output& o);
    bool writeOutput(const mlx90614::Output o, const bool apply = true);
    bool readIIR(mlx90614::IIR& iir);
    bool writeIIR(const mlx90614::IIR iir, const bool apply = true);
    bool readFIR(mlx90614::FIR& fir);
    bool writeFIR(const mlx90614::FIR fir, const bool apply = true);
    bool readGain(mlx90614::Gain& gain);
    bool writeGain(const mlx90614::Gain gain, const bool apply = true);
    bool readIRSensor(mlx90614::IRSensor& irs);
    bool writeIRSensor(const mlx90614::IRSensor irs, const bool apply = true);
    bool readPositiveKs(bool& pos);
    bool writePositiveKs(const bool pos, const bool apply = true);
    bool readPositiveKf2(bool& pos);
    bool writePositiveKf2(const bool pos, const bool apply = true);
 
 
    bool readObjectMinMax(uint16_t& toMin, uint16_t& toMax);
    bool readObjectMinMax(float& toMin, float& toMax);
    template <typename T, typename std::enable_if<std::is_integral<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeObjectMinMax(const T toMin, const T toMax, const bool apply = true)
    {
        return write_object_minmax((uint16_t)toMin, (uint16_t)toMax, apply);
    }
    bool writeObjectMinMax(const float toMin, const float toMax, const bool apply = true);
    bool readAmbientMinMax(uint8_t& taMin, uint8_t& taMax);
    bool readAmbientMinMax(float& taMin, float& taMax);
    template <typename T, typename std::enable_if<std::is_integral<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeAmbientMinMax(const T taMin, const T taMax, const bool apply = true)
    {
        return write_ambient_minmax((uint8_t)taMin, (uint8_t)taMax, apply);
    }
    bool writeAmbientMinMax(const float taMin, const float taMax, const bool apply = true);
 
 
    bool readEmissivity(uint16_t& emiss);
    bool readEmissivity(float& emiss);
    template <typename T, typename std::enable_if<std::is_integral<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeEmissivity(const T emiss, const bool apply = true)
    {
        return write_emissivity((uint16_t)emiss, apply);
    }
    bool writeEmissivity(const float emiss, const bool apply = true);
 
 
    bool changeI2CAddress(const uint8_t i2c_address);
    bool readI2CAddress(uint8_t& i2c_address);
 
    bool sleep();
    bool wakeup();
    inline bool applySettings()
    {
        return sleep() && wakeup();
    }
 
protected:
    bool read_eeprom(mlx90614::EEPROM& e);
    bool read_register16(const uint8_t reg, uint16_t& v, const bool stopbit = false);
    bool write_register16(const uint8_t reg, const uint16_t val);
    bool write_eeprom(const uint8_t reg, const uint16_t val, const bool apply = true);
    bool write_object_minmax(const uint16_t toMin, const uint16_t toMax, const bool apply = true);
    bool write_ambient_minmax(const uint8_t taMin, const uint8_t taMax, const bool apply = true);
    bool write_emissivity(const uint16_t emiss, const bool apply = true);
    bool read_measurement(mlx90614::Data& d, const uint16_t config);
 
    bool start_periodic_measurement(const mlx90614::IIR iir, const mlx90614::FIR fir, const mlx90614::Gain gain,
                                    const mlx90614::IRSensor irs);
    bool start_periodic_measurement();
    bool stop_periodic_measurement();
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitMLX90614, mlx90614::Data);
 
    virtual uint32_t get_interval(const mlx90614::IIR iir, const mlx90614::FIR fir);
    virtual bool has_dual_sensors() const
    {
        return false;
    }
 
private:
    std::unique_ptr<m5::container::CircularBuffer<mlx90614::Data>> _data{};
    mlx90614::EEPROM _eeprom{};
    config_t _cfg{};
};
 
class UnitMLX90614BAA : public UnitMLX90614 {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitMLX90614BAA, 0x5A);
 
public:
    explicit UnitMLX90614BAA(const uint8_t addr = DEFAULT_ADDRESS) : UnitMLX90614(addr)
    {
    }
 
protected:
    virtual uint32_t get_interval(const mlx90614::IIR iir, const mlx90614::FIR fir);
    inline virtual bool has_dual_sensors() const
    {
        return true;
    }
};
 
namespace mlx90614 {
namespace command {
// Category bits
constexpr uint8_t COMMAND_RAM{0x00};          // 000xxxxx
constexpr uint8_t COMMAND_EEPROM{0x20};       // 001xxxxx
constexpr uint8_t COMMAND_READ_FLAGS{0xF0};   // 11110000
constexpr uint8_t COMMAND_ENTER_SLEEP{0xFF};  // 11111111 This mode is not available for the 5V supply version
// RAM
constexpr uint8_t READ_RAW_AMBIENT{0x03};
constexpr uint8_t READ_RAW_IR1{0x04};
constexpr uint8_t READ_RAW_IR2{0x05};
constexpr uint8_t READ_TAMBIENT{0x06};
constexpr uint8_t READ_TOBJECT_1{0x07};
constexpr uint8_t READ_TOBJECT_2{0x08};
// EEPROM
constexpr uint8_t EEPROM_TO_MAX{0x20};
constexpr uint8_t EEPROM_TO_MIN{0x21};
constexpr uint8_t EEPROM_PWMCTRL{0x22};
constexpr uint8_t EEPROM_TARANGE{0x23};
constexpr uint8_t EEPROM_EMISSIVITY{0x24};
constexpr uint8_t EEPROM_CONFIG{0x25};
constexpr uint8_t EEPROM_ADDR{0x2E};
constexpr uint8_t EEPROM_ID0{0x3C};
constexpr uint8_t EEPROM_ID1{0x3D};
constexpr uint8_t EEPROM_ID2{0x3E};
constexpr uint8_t EEPROM_ID3{0x3F};
 
}  // namespace command
}  // namespace mlx90614
 
}  // namespace unit
}  // namespace m5
 
#endif