bmp581_types.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "bmp581_registers.hpp"
 
#include <cstdint>
#include <string_view>
 
namespace bmp581 {
 
enum class DriverError : uint8_t {
    None = 0,
    InvalidParameter,
    NotInitialized,   
    Bus,              
    InvalidChipId,    
    NvmNotReady,      
    PorSoftReset,     
    InvalidPowerMode,
    NvmInvalidAddr,   
    NvmCommandError,  
};
 
constexpr std::string_view ToString(DriverError e) noexcept {
    switch (e) {
        case DriverError::None:             return "None";
        case DriverError::InvalidParameter: return "InvalidParameter";
        case DriverError::NotInitialized:   return "NotInitialized";
        case DriverError::Bus:              return "Bus";
        case DriverError::InvalidChipId:    return "InvalidChipId";
        case DriverError::NvmNotReady:      return "NvmNotReady";
        case DriverError::PorSoftReset:     return "PorSoftReset";
        case DriverError::InvalidPowerMode: return "InvalidPowerMode";
        case DriverError::NvmInvalidAddr:   return "NvmInvalidAddr";
        case DriverError::NvmCommandError:  return "NvmCommandError";
    }
    return "?";
}
 
template <typename T>
struct DriverResult {
    T value{};
    DriverError error{DriverError::None};
 
    constexpr bool ok() const noexcept { return error == DriverError::None; }
    constexpr explicit operator bool() const noexcept { return ok(); }
 
    static constexpr DriverResult success(T v) noexcept { return {v, DriverError::None}; }
    static constexpr DriverResult failure(DriverError e) noexcept { return {T{}, e}; }
};
 
template <>
struct DriverResult<void> {
    DriverError error{DriverError::None};
    constexpr bool ok() const noexcept { return error == DriverError::None; }
    constexpr explicit operator bool() const noexcept { return ok(); }
    static constexpr DriverResult success() noexcept { return {DriverError::None}; }
    static constexpr DriverResult failure(DriverError e) noexcept { return {e}; }
};
 
constexpr std::string_view ToString(PowerMode m) noexcept {
    switch (m) {
        case PowerMode::Standby:     return "Standby";
        case PowerMode::Normal:      return "Normal";
        case PowerMode::Forced:      return "Forced";
        case PowerMode::Continuous:  return "Continuous";
        case PowerMode::DeepStandby: return "DeepStandby";
    }
    return "?";
}
 
struct OsrOdrConfig {
    Oversampling osr_temperature{Oversampling::X1};
    Oversampling osr_pressure{Oversampling::X1};
    bool pressure_enable{true};
    Odr odr{Odr::Hz50};
};
 
struct IirConfig {
    IirFilter temperature{IirFilter::Bypass};
    IirFilter pressure{IirFilter::Bypass};
    bool shadow_iir_temperature{true};  
    bool shadow_iir_pressure{true};     
    bool flush_forced_enable{false};    
};
 
struct EffectiveOsr {
    Oversampling osr_temperature{Oversampling::X1};
    Oversampling osr_pressure{Oversampling::X1};
    bool odr_valid{true};  
};
 
struct InterruptConfig {
    IntMode mode{IntMode::Pulsed};
    IntPolarity polarity{IntPolarity::ActiveHigh};
    IntDrive drive{IntDrive::PushPull};
    bool enable{false};
};
 
struct InterruptSources {
    bool data_ready{false};
    bool fifo_full{false};
    bool fifo_threshold{false};
    bool pressure_out_of_range{false};
};
 
struct Sample {
    uint32_t pressure_raw{0};   
    int32_t temperature_raw{0}; 
    float pressure_pa{0.0f};
    float temperature_c{0.0f};
};
 
struct Config {
    OsrOdrConfig osr_odr{};
    IirConfig iir{};
    PowerMode power_mode{PowerMode::Normal};
};
 
constexpr Config BarometricReferencePreset() noexcept {
    Config c{};
    c.osr_odr.osr_pressure = Oversampling::X8;
    c.osr_odr.osr_temperature = Oversampling::X1;
    c.osr_odr.pressure_enable = true;
    c.osr_odr.odr = Odr::Hz100_2;
    c.iir.pressure = IirFilter::Coeff3;
    c.iir.temperature = IirFilter::Coeff3;
    c.power_mode = PowerMode::Normal;
    return c;
}
 
}  // namespace bmp581