fdo2_types.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <cstdint>
#include <string_view>
 
namespace fdo2 {
 
constexpr uint32_t kFdo2G2DefaultBaud = 19200U;
 
constexpr uint32_t kFdo2G2PowerUpSettleMs = 1100U;
 
enum class DriverError : uint8_t {
    None = 0,
    InvalidParameter,
    Timeout,
    BufferOverflow,
    ProtocolError,
    DeviceError,
    CrcMismatch,  
};
 
constexpr std::string_view ToString(DriverError e) noexcept {
    switch (e) {
        case DriverError::None:              return "None";
        case DriverError::InvalidParameter: return "InvalidParameter";
        case DriverError::Timeout:          return "Timeout";
        case DriverError::BufferOverflow:   return "BufferOverflow";
        case DriverError::ProtocolError:    return "ProtocolError";
        case DriverError::DeviceError:      return "DeviceError";
        case DriverError::CrcMismatch:      return "CrcMismatch";
    }
    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}; }
};
 
struct VersionInfo {
    int32_t device_id{};          
    int32_t num_channels{};     
    int32_t firmware_revision{};
    int32_t sensor_types{};     
};
 
constexpr double FirmwareRevisionToDouble(int32_t r) noexcept {
    return static_cast<double>(r) * 0.01;
}
 
struct MoxyReading {
    int32_t  o_raw{};       
    int32_t  t_raw{};       
    uint32_t status_u32{};  
 
    double p_o2_hpa{}; 
    double temp_c{};   
};
 
struct MrawReading : MoxyReading {
    int32_t d_raw{}; 
    int32_t i_raw{}; 
    int32_t a_raw{}; 
    int32_t p_raw{}; 
    int32_t h_raw{}; 
 
    double dphi_deg{};          
    double signal_intensity_mv{}; 
    double ambient_light_mv{};    
    double pressure_mbar{};       
    double rh_in_housing_pct{};   
};
 
namespace moxy_status {
 
constexpr uint32_t kWarnAutoAmpReduced = 1U << 0;
constexpr uint32_t kFatalSignalTooLow  = 1U << 1;
constexpr uint32_t kFatalSignalTooHigh = 1U << 2;
constexpr uint32_t kFatalRefTooLow     = 1U << 3;
constexpr uint32_t kFatalRefTooHigh    = 1U << 4;
constexpr uint32_t kFatalTempSensor    = 1U << 5;
constexpr uint32_t kWarnHumidityHigh   = 1U << 7;
constexpr uint32_t kErrPressureSensor    = 1U << 9;
constexpr uint32_t kErrHumiditySensor    = 1U << 10;
 
}  // namespace moxy_status
 
constexpr bool MoxyStatusOkForOxygen(uint32_t s) noexcept { return s <= 1U; }
 
inline MoxyReading DecodeMoxy(int32_t o_raw, int32_t t_raw, uint32_t s) noexcept {
    MoxyReading m{};
    m.o_raw      = o_raw;
    m.t_raw      = t_raw;
    m.status_u32 = s;
    m.p_o2_hpa   = static_cast<double>(o_raw) * 1e-3;
    m.temp_c     = static_cast<double>(t_raw) * 1e-3;
    return m;
}
 
inline MrawReading DecodeMraw(int32_t o_raw, int32_t t_raw, uint32_t s, int32_t d_raw,
                               int32_t i_raw, int32_t a_raw, int32_t p_raw,
                               int32_t h_raw) noexcept {
    MrawReading r{};
    static_cast<MoxyReading&>(r) = DecodeMoxy(o_raw, t_raw, s);
    r.d_raw                  = d_raw;
    r.i_raw                  = i_raw;
    r.a_raw                  = a_raw;
    r.p_raw                  = p_raw;
    r.h_raw                  = h_raw;
    r.dphi_deg               = static_cast<double>(d_raw) * 1e-3;
    r.signal_intensity_mv    = static_cast<double>(i_raw) * 1e-3;
    r.ambient_light_mv       = static_cast<double>(a_raw) * 1e-3;
    r.pressure_mbar          = static_cast<double>(p_raw) * 1e-3;  /* µbar → mbar */
    r.rh_in_housing_pct      = static_cast<double>(h_raw) * 1e-3;
    return r;
}
 
inline double VolumePercentO2(double p_o2_hpa, double p_air_mbar) noexcept {
    if (p_air_mbar <= 0.0 || !std::isfinite(p_air_mbar) || !std::isfinite(p_o2_hpa)) {
        return 0.0;
    }
    return 100.0 * p_o2_hpa / p_air_mbar;
}
 
}  // namespace fdo2