unit_SPA06_data.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_ENV_UNIT_SPA06_DATA_HPP
#define M5_UNIT_ENV_UNIT_SPA06_DATA_HPP
 
#include <array>
#include <cstdint>
#include <cmath>
#include <limits>
 
namespace m5 {
namespace unit {
namespace spa06 {
 
enum class Oversampling : uint8_t {
    X1,    
    X2,    
    X4,    
    X8,    
    X16,   
    X32,   
    X64,   
    X128,  
};
 
enum class Rate : uint8_t {
    Rate1,    
    Rate2,    
    Rate4,    
    Rate8,    
    Rate16,   
    Rate32,   
    Rate64,   
    Rate128,  
};
 
enum class Mode : uint8_t {
    Pressure               = 0x05,  
    Temperature            = 0x06,  
    PressureAndTemperature = 0x07,  
};
 
inline float scale_factor(const Oversampling oversampling)
{
    switch (oversampling) {
        case Oversampling::X1:
            return 524288.0f;
        case Oversampling::X2:
            return 1572864.0f;
        case Oversampling::X4:
            return 3670016.0f;
        case Oversampling::X8:
            return 7864320.0f;
        case Oversampling::X16:
            return 253952.0f;
        case Oversampling::X32:
            return 516096.0f;
        case Oversampling::X64:
            return 1040384.0f;
        case Oversampling::X128:
            return 2088960.0f;
    }
    return std::numeric_limits<float>::quiet_NaN();  // Out-of-range enum value
}
 
inline uint32_t measurement_time_x10(const Oversampling oversampling)
{
    constexpr uint32_t t[] = {36, 52, 84, 148, 276, 532, 1044, 2068};
    return t[static_cast<uint8_t>(oversampling)];
}
 
inline bool valid_combination(const Oversampling osrs_p, const Oversampling osrs_t, const Rate rate, const Mode mode)
{
    const uint32_t r = static_cast<uint32_t>(1) << static_cast<uint8_t>(rate);  // measurements per second
    uint32_t budget_x10{};
    switch (mode) {
        case Mode::Pressure:
            budget_x10 = measurement_time_x10(osrs_p);
            break;
        case Mode::Temperature:
            budget_x10 = measurement_time_x10(osrs_t);
            break;
        case Mode::PressureAndTemperature:
            budget_x10 = measurement_time_x10(osrs_p) + measurement_time_x10(osrs_t);
            break;
    }
    return r * budget_x10 < 10000u;  // < 1000 ms (values are ms x10)
}
 
constexpr int32_t NOT_MEASURED{-8388608};
 
inline int32_t sign_extend(const uint32_t v, const uint8_t bits)
{
    const uint32_t m = static_cast<uint32_t>(1) << (bits - 1);
    return static_cast<int32_t>((v ^ m) - m);
}
 
struct coeffs_t {
    int32_t c0{}, c1{};
    int32_t c00{}, c10{};
    int32_t c01{}, c11{}, c20{}, c21{}, c30{};
    int32_t c31{}, c40{};
};
 
inline coeffs_t parse_coeffs(const std::array<uint8_t, 21>& r)
{
    coeffs_t c{};
    c.c0  = sign_extend((static_cast<uint32_t>(r[0]) << 4) | (r[1] >> 4), 12);
    c.c1  = sign_extend(((static_cast<uint32_t>(r[1]) & 0x0F) << 8) | r[2], 12);
    c.c00 = sign_extend((static_cast<uint32_t>(r[3]) << 12) | (static_cast<uint32_t>(r[4]) << 4) | (r[5] >> 4), 20);
    c.c10 = sign_extend(((static_cast<uint32_t>(r[5]) & 0x0F) << 16) | (static_cast<uint32_t>(r[6]) << 8) | r[7], 20);
    c.c01 = sign_extend((static_cast<uint32_t>(r[8]) << 8) | r[9], 16);
    c.c11 = sign_extend((static_cast<uint32_t>(r[10]) << 8) | r[11], 16);
    c.c20 = sign_extend((static_cast<uint32_t>(r[12]) << 8) | r[13], 16);
    c.c21 = sign_extend((static_cast<uint32_t>(r[14]) << 8) | r[15], 16);
    c.c30 = sign_extend((static_cast<uint32_t>(r[16]) << 8) | r[17], 16);
    c.c31 = sign_extend((static_cast<uint32_t>(r[18]) << 4) | (r[19] >> 4), 12);
    c.c40 = sign_extend(((static_cast<uint32_t>(r[19]) & 0x0F) << 8) | r[20], 12);
    return c;
}
 
inline float compensate_temperature(const int32_t tmp_raw, const coeffs_t& c, const float kt)
{
    const float traw_sc = tmp_raw / kt;
    return c.c0 * 0.5f + c.c1 * traw_sc;
}
 
inline float compensate_pressure(const int32_t psr_raw, const int32_t tmp_raw, const coeffs_t& c, const float kp,
                                 const float kt)
{
    const float praw_sc = psr_raw / kp;
    const float traw_sc = tmp_raw / kt;
    return c.c00 + praw_sc * (c.c10 + praw_sc * (c.c20 + praw_sc * (c.c30 + praw_sc * c.c40))) + traw_sc * c.c01 +
           traw_sc * praw_sc * (c.c11 + praw_sc * (c.c21 + praw_sc * c.c31));
}
 
inline float altitude_m(const float pressure_hpa, const float sea_level_hpa)
{
    return 44330.0f * (1.0f - std::pow(pressure_hpa / sea_level_hpa, 1.0f / 5.255f));
}
 
struct Data {
    std::array<uint8_t, 6> raw{};  
    coeffs_t coeffs{};
    float kp{};  
    float kt{};  
 
    inline int32_t psr_raw() const
    {
        return sign_extend((static_cast<uint32_t>(raw[0]) << 16) | (static_cast<uint32_t>(raw[1]) << 8) | raw[2], 24);
    }
    inline int32_t tmp_raw() const
    {
        return sign_extend((static_cast<uint32_t>(raw[3]) << 16) | (static_cast<uint32_t>(raw[4]) << 8) | raw[5], 24);
    }
    inline float temperature() const
    {
        return (kt != 0.0f && tmp_raw() != NOT_MEASURED) ? compensate_temperature(tmp_raw(), coeffs, kt)
                                                         : std::numeric_limits<float>::quiet_NaN();
    }
    inline float celsius() const
    {
        return temperature();
    }
    inline float fahrenheit() const
    {
        return celsius() * 9.0f / 5.0f + 32.0f;
    }
    inline float pressure() const
    {
        return (kp != 0.0f && kt != 0.0f && psr_raw() != NOT_MEASURED)
                   ? compensate_pressure(psr_raw(), tmp_raw(), coeffs, kp, kt) / 100.0f  // Pa -> hPa
                   : std::numeric_limits<float>::quiet_NaN();
    }
};
 
}  // namespace spa06
}  // namespace unit
}  // namespace m5
#endif