unit_MCP_H10.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_TUBE_UNIT_MCP_H10_HPP
#define M5_UNIT_TUBE_UNIT_MCP_H10_HPP
 
#include <M5UnitComponent.hpp>
#include <limits>  // NaN
 
namespace m5 {
namespace unit {
 
namespace mcp_h10 {
 
struct Data {
    uint16_t raw{};   // Raw data
    float voltage{};  // Calculated voltage
 
    inline float pressure() const
    {
        return voltage * k + b;
    }
 
    float k{}, b{};
};
 
}  // namespace mcp_h10
 
class UnitMCP_H10 : public Component, public PeriodicMeasurementAdapter<UnitMCP_H10, mcp_h10::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitMCP_H10, 0x00 /* No I2C */);
 
public:
    explicit UnitMCP_H10(const float minV, const float maxV, const float coefficient, const float offset)
        : Component(DEFAULT_ADDRESS),
          _data{new m5::container::CircularBuffer<mcp_h10::Data>(1)},
          _minV{minV},
          _maxV{maxV},
          _coefficient{coefficient},
          _offset{offset}
    {
    }
    virtual ~UnitMCP_H10() = default;
 
    virtual bool begin() override;
    virtual void update(const bool force = false) override;
 
    struct config_t {
        bool start_periodic{true};
        uint32_t interval_ms{100};
        float calib_vzero{};
    };
 
 
    inline config_t config()
    {
        return _cfg;
    }
    inline void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
    inline float coefficient() const
    {
        return _coefficient;
    }
    inline float offset() const
    {
        return _offset;
    }
    inline float minimumVoltage() const
    {
        return _minV;
    }
    inline float maximumVoltage() const
    {
        return _maxV;
    }
    inline float voltageRange() const
    {
        return maximumVoltage() - minimumVoltage();
    }
 
 
    inline float pressure() const
    {
        return !empty() ? oldest().pressure() : std::numeric_limits<float>::quiet_NaN();
    }
 
 
    inline bool startPeriodicMeasurement(const uint32_t interval)
    {
        return PeriodicMeasurementAdapter<UnitMCP_H10, mcp_h10::Data>::startPeriodicMeasurement(interval);
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitMCP_H10, mcp_h10::Data>::stopPeriodicMeasurement();
    }
 
 
    bool measureSingleshot(mcp_h10::Data& d);
 
    inline bool isCalibrated() const
    {
        return _calib_zero_diff != 0.0f;
    }
    void setCalibration(const float vzero)
    {
        const float ideal_zero_voltage = -offset() / coefficient();
        _calib_zero_diff               = vzero - ideal_zero_voltage;
    }
    inline void clearCalibration()
    {
        _calib_zero_diff = 0.0f;
    };
 
protected:
    bool read_measurement(mcp_h10::Data& d);
    bool start_periodic_measurement(const uint32_t interval);
    bool stop_periodic_measurement();
 
    std::unique_ptr<m5::container::CircularBuffer<mcp_h10::Data>> _data{};
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitMCP_H10, mcp_h10::Data);
 
private:
    float _minV{}, _maxV{}, _coefficient{}, _offset{};
    float _calib_zero_diff{};
    config_t _cfg{};
};
 
class UnitMCP_H10_B200KPPN : public UnitMCP_H10 {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitMCP_H10_B200KPPN, 0x00 /* No I2C */);
 
public:
    explicit UnitMCP_H10_B200KPPN() : UnitMCP_H10(0.1f, 3.1f, 100.f, -110.f)
    {
    }
    virtual ~UnitMCP_H10_B200KPPN() = default;
};
 
}  // namespace unit
}  // namespace m5
#endif