unit_MAX30100.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_HEART_UNIT_MAX30100_HPP
#define M5_UNIT_HEART_UNIT_MAX30100_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/stl/extension.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <limits>  // NaN
 
namespace m5 {
namespace unit {
namespace max30100 {
enum class Mode : uint8_t {
    None,           
    HROnly = 0x02,  
    SPO2,           
};
 
struct ModeConfiguration {
    bool shdn() const
    {
        return value & (1U << 7);
    }  
    bool reset() const
    {
        return value & (1U << 6);
    }  
    bool temperature() const
    {
        return value & (1U << 3);
    }  
    Mode mode() const
    {
        return static_cast<Mode>(value & 0x07);
    }  
 
    void shdn(const bool b)
    {
        value = (value & ~(1U << 7)) | ((b ? 1 : 0) << 7);
    }  
    void reset(const bool b)
    {
        value = (value & ~(1U << 6)) | ((b ? 1 : 0) << 6);
    }  
    void temperature(const bool b)
    {
        value = (value & ~(1U << 3)) | ((b ? 1 : 0) << 3);
    }  
    void mode(const Mode m)
    {
        value = (value & ~0x07) | (m5::stl::to_underlying(m) & 0x07);
    }  
 
    uint8_t value{};
};
 
enum class Sampling : uint8_t {
    Rate50,    
    Rate100,   
    Rate167,   
    Rate200,   
    Rate400,   
    Rate600,   
    Rate800,   
    Rate1000,  
};
 
uint32_t getSamplingRate(const Sampling rate);
 
enum class LedPulseWidth {
    PW200,   
    PW400,   
    PW800,   
    PW1600,  
};
 
struct SpO2Configuration {
    bool highResolution() const
    {  // for SpO2
        return value & (1U << 6);
    }
    Sampling samplingRate() const
    {
        return static_cast<Sampling>((value >> 2) & 0x07);
    }
    LedPulseWidth ledPulseWidth() const
    {
        return static_cast<LedPulseWidth>(value & 0x03);
    }
 
    void highResolution(const bool b)
    {  // for SpO2
        value = (value & ~(1U << 6)) | ((b ? 1 : 0) << 6);
    }
    void samplingRate(const Sampling rate)
    {
        value = (value & ~(0x07 << 2)) | ((m5::stl::to_underlying(rate) & 0x07) << 2);
    }
    void ledPulseWidth(const LedPulseWidth width)
    {
        value = (value & ~0x03) | (m5::stl::to_underlying(width) & 0x03);
    }
 
    uint8_t value{};
};
 
enum class CurrentControl {
    mA0_0,   
    mA4_4,   
    mA7_6,   
    mA11_0,  
    mA14_2,  
    mA17_4,  
    mA20_8,  
    mA24_0,  
    mA27_1,  
    mA30_6,  
    mA33_8,  
    mA37_0,  
    mA40_2,  
    mA43_6,  
    mA46_8,  
    mA50_0,  
};
 
struct LedConfiguration {
    CurrentControl red() const
    {
        return static_cast<CurrentControl>((value >> 4) & 0x0F);
    }
    CurrentControl ir() const
    {
        return static_cast<CurrentControl>(value & 0x0F);
    }
    void red(const CurrentControl cc)
    {
        value = (value & ~(0x0F << 4)) | ((m5::stl::to_underlying(cc) & 0x0F) << 4);
    }
    void ir(const CurrentControl cc)
    {
        value = (value & ~0x0F) | (m5::stl::to_underlying(cc) & 0x0F);
    }
    uint8_t value{};
};
 
constexpr uint8_t MAX_FIFO_DEPTH{16};
 
struct Data {
    std::array<uint8_t, 4> raw{};
    uint16_t ir() const;   
    uint16_t red() const;  
};
 
struct TemperatureData {
    std::array<uint8_t, 2> raw{};
    inline float temperature() const
    {
        return celsius();
    }
    float celsius() const;     
    float fahrenheit() const;  
};
 
}  // namespace max30100
 
class UnitMAX30100 : public Component, public PeriodicMeasurementAdapter<UnitMAX30100, max30100::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitMAX30100, 0x57);
 
public:
    struct config_t {
        bool start_periodic{true};
        max30100::Mode mode{max30100::Mode::SPO2};
        max30100::Sampling sampling_rate{m5::unit::max30100::Sampling::Rate100};
        max30100::LedPulseWidth pulse_width{m5::unit::max30100::LedPulseWidth::PW1600};
        m5::unit::max30100::CurrentControl ir_current{m5::unit::max30100::CurrentControl::mA27_1};
        bool high_resolution{true};
        m5::unit::max30100::CurrentControl red_current{m5::unit::max30100::CurrentControl::mA27_1};
    };
 
    explicit UnitMAX30100(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<max30100::Data>(max30100::MAX_FIFO_DEPTH)}
    {
        auto ccfg        = component_config();
        ccfg.clock       = 400 * 1000U;
        ccfg.stored_size = max30100::MAX_FIFO_DEPTH;
        component_config(ccfg);
    }
    virtual ~UnitMAX30100()
    {
    }
 
    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;
    }
 
    inline uint16_t ir() const
    {
        return !empty() ? oldest().ir() : 0;
    }
    inline uint16_t red() const
    {
        return !empty() ? oldest().red() : 0;
    }
    inline uint8_t retrived() const
    {
        return _retrived;
    }
    inline uint8_t overflow() const
    {
        return _overflow;
    }
 
 
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitMAX30100, max30100::Data>::startPeriodicMeasurement();
    }
    inline bool startPeriodicMeasurement(const max30100::Mode mode, const max30100::Sampling sample_rate,
                                         const max30100::LedPulseWidth pulse_width,
                                         const max30100::CurrentControl ir_current, const bool high_resolution = false,
                                         const max30100::CurrentControl red_current = max30100::CurrentControl::mA0_0)
    {
        return PeriodicMeasurementAdapter<UnitMAX30100, max30100::Data>::startPeriodicMeasurement(
            mode, sample_rate, pulse_width, ir_current, high_resolution, red_current);
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitMAX30100, max30100::Data>::stopPeriodicMeasurement();
    }
 
 
    bool readModeConfiguration(max30100::ModeConfiguration& mc);
    bool writeModeConfiguration(const max30100::ModeConfiguration mc);
    bool writeMode(const max30100::Mode mode);
    bool writePowerSaveEnable()
    {
        return enable_power_save(true);
    }
    bool writePowerSaveDisable()
    {
        return enable_power_save(false);
    }
 
 
    bool readSpO2Configuration(max30100::SpO2Configuration& sc);
    bool writeSpO2Configuration(const max30100::SpO2Configuration sc);
    bool writeSamplingRate(const max30100::Sampling rate);
    bool writeLedPulseWidth(const max30100::LedPulseWidth width);
    inline bool writeHighResolutionEnable()
    {
        return enable_high_resolution(true);
    }
    inline bool writeHighResolutionDisable()
    {
        return enable_high_resolution(false);
    }
 
 
    bool readLedConfiguration(max30100::LedConfiguration& lc);
    bool writeLedConfiguration(const max30100::LedConfiguration lc);
    bool writeLedCurrent(const max30100::CurrentControl ir, const max30100::CurrentControl red);
 
 
    bool measureTemperatureSingleshot(max30100::TemperatureData& td);
 
    bool resetFIFO();
    bool reset();
 
protected:
    bool start_periodic_measurement();
    bool start_periodic_measurement(const max30100::Mode mode, const max30100::Sampling sample_rate,
                                    const max30100::LedPulseWidth pulse_width,
                                    const max30100::CurrentControl ir_current, const bool high_resolution,
                                    const max30100::CurrentControl red_current);
    bool stop_periodic_measurement();
 
    bool read_FIFO();
    bool read_measurement_temperature(max30100::TemperatureData& td);
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitMAX30100, max30100::Data);
 
    bool read_mode_configration(uint8_t& c);
    bool write_mode_configration(const uint8_t c);
    bool enable_power_save(const bool enabled);
    bool read_spo2_configration(uint8_t& c);
    bool write_spo2_configration(const uint8_t c);
    bool enable_high_resolution(const bool enabled);
    bool read_led_configration(uint8_t& c);
    bool write_led_configration(const uint8_t c);
 
    bool read_register(const uint8_t reg, uint8_t* buf, const size_t len);
    bool read_register8(const uint8_t reg, uint8_t& v);
 
protected:
    max30100::Mode _mode{max30100::Mode::None};
    uint8_t _retrived{}, _overflow{};
    std::unique_ptr<m5::container::CircularBuffer<max30100::Data>> _data{};
 
    config_t _cfg{};
};
 
namespace max30100 {
namespace command {
// STATUS
constexpr uint8_t READ_INTERRUPT_STATUS{0x00};
constexpr uint8_t INTERRUPT_ENABLE{0x01};
// FIFO
constexpr uint8_t FIFO_WRITE_POINTER{0x02};
constexpr uint8_t FIFO_OVERFLOW_COUNTER{0x03};
constexpr uint8_t FIFO_READ_POINTER{0x04};
// Note that FIFO_DATA_REGISTER cannot be burst read.
constexpr uint8_t FIFO_DATA_REGISTER{0x05};
// CONFIGURATION
constexpr uint8_t MODE_CONFIGURATION{0x06};
constexpr uint8_t SPO2_CONFIGURATION{0x07};
constexpr uint8_t LED_CONFIGURATION{0x09};
// TEMPERATURE
constexpr uint8_t TEMP_INTEGER{0x16};
constexpr uint8_t TEMP_FRACTION{0x17};
// PART ID
constexpr uint8_t READ_REVISION_ID{0xFE};
constexpr uint8_t PART_ID{0xFF};
 
}  // namespace command
}  // namespace max30100
 
}  // namespace unit
}  // namespace m5
 
#endif