sfm_types.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "sfm_commands.hpp"
 
#include <cstdint>
#include <string_view>
 
namespace sfm {
 
enum class DriverError : uint8_t {
    None = 0,
    InvalidParameter,   
    NotInitialized,     
    BusWrite,           
    BusRead,            
    NoData,             
    Crc,                
    UnsupportedGas,     
    NotSupported,       
    UnexpectedUnit,     
    VariantUnknown,     
};
 
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::BusWrite:         return "BusWrite";
        case DriverError::BusRead:          return "BusRead";
        case DriverError::NoData:           return "NoData";
        case DriverError::Crc:              return "Crc";
        case DriverError::UnsupportedGas:   return "UnsupportedGas";
        case DriverError::NotSupported:     return "NotSupported";
        case DriverError::UnexpectedUnit:   return "UnexpectedUnit";
        case DriverError::VariantUnknown:   return "VariantUnknown";
    }
    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}; }
};
 
enum class Family : uint8_t {
    Sf06 = 0,  
    Sfx6000,   
};
 
constexpr std::string_view ToString(Family f) noexcept {
    return f == Family::Sfx6000 ? "SFx6000" : "SF06";
}
 
enum class Gas : uint8_t {
    O2 = 0,      
    Air,         
    N2O,         
    CO2,         
    AirO2Mix,    
    N2OO2Mix,    
    CO2O2Mix,    
    Ar,          
    HeOx,        
    HeOxO2Mix,   
};
 
constexpr std::string_view ToString(Gas g) noexcept {
    switch (g) {
        case Gas::O2:       return "O2";
        case Gas::Air:      return "Air";
        case Gas::N2O:      return "N2O";
        case Gas::CO2:      return "CO2";
        case Gas::AirO2Mix: return "Air/O2";
        case Gas::N2OO2Mix: return "N2O/O2";
        case Gas::CO2O2Mix: return "CO2/O2";
        case Gas::Ar:       return "Ar";
        case Gas::HeOx:     return "HeOx";
        case Gas::HeOxO2Mix: return "HeOx/O2";
    }
    return "?";
}
 
constexpr uint16_t StartCommandFor(Family family, Gas g) noexcept {
    if (family == Family::Sfx6000) {
        switch (g) {
            case Gas::O2:       return cmd::kSfx6000StartGas0;
            case Gas::Air:      return cmd::kSfx6000StartGas1;
            case Gas::CO2:      return cmd::kSfx6000StartGas2;
            case Gas::N2O:      return cmd::kSfx6000StartGas3;
            case Gas::Ar:       return cmd::kSfx6000StartGas4;
            case Gas::AirO2Mix: return cmd::kSfx6000StartMix0;
            case Gas::N2OO2Mix:
            case Gas::CO2O2Mix:
            case Gas::HeOx:
            case Gas::HeOxO2Mix: return 0;
        }
        return 0;
    }
    switch (g) {
        case Gas::O2:       return cmd::kStartO2;
        case Gas::Air:      return cmd::kStartAir;
        case Gas::N2O:      return cmd::kStartN2O;
        case Gas::CO2:      return cmd::kStartCO2;
        case Gas::AirO2Mix: return cmd::kStartAirO2Mix;
        case Gas::N2OO2Mix: return cmd::kStartN2OO2Mix;
        case Gas::CO2O2Mix: return cmd::kStartCO2O2Mix;
        case Gas::HeOx:     return cmd::kStartN2O;       // 0x3615 is HeOx on the SFM3013-300-CLM
        case Gas::HeOxO2Mix: return cmd::kStartN2OO2Mix;  // 0x3639 is HeOx/O2 on the SFM3013-300-CLM
        case Gas::Ar:       return 0;
    }
    return 0;
}
 
static_assert(StartCommandFor(Family::Sf06, Gas::CO2) == 0x361E &&
                  StartCommandFor(Family::Sfx6000, Gas::CO2) == 0x3615,
              "CO2 start code differs by family (SFM4300 data sheet / SFx6000 reference)");
 
constexpr bool IsMixture(Gas g) noexcept {
    return g == Gas::AirO2Mix || g == Gas::N2OO2Mix || g == Gas::CO2O2Mix || g == Gas::HeOxO2Mix;
}
 
enum class Variant : uint8_t {
    Unknown = 0,
    Sfm4300_20_B,  
    Sfm4300_20_O,  
    Sfm4300_20_P,  
    Sfm4300_50_B,  
    Sfm4300_50_O,  
    Sfm4300_50_P,  
    Sfm6000D_50,   
    Sfm6000D_20,   
    Sfm6000D_5,    
    Sfm3003_300_CL,   
    Sfm3003_300_CE,   
    Sfm3013_300_CL,   
    Sfm3013_300_CLM,  
    Sfm3019_240,      
    Sfm3119_240_CL,   
};
 
constexpr std::string_view ToString(Variant v) noexcept {
    switch (v) {
        case Variant::Unknown:      return "Unknown";
        case Variant::Sfm4300_20_B: return "SFM4300-20-B";
        case Variant::Sfm4300_20_O: return "SFM4300-20-O";
        case Variant::Sfm4300_20_P: return "SFM4300-20-P";
        case Variant::Sfm4300_50_B: return "SFM4300-50-B";
        case Variant::Sfm4300_50_O: return "SFM4300-50-O";
        case Variant::Sfm4300_50_P: return "SFM4300-50-P";
        case Variant::Sfm6000D_50:  return "SFM6000D-50";
        case Variant::Sfm6000D_20:  return "SFM6000D-20";
        case Variant::Sfm6000D_5:   return "SFM6000D-5";
        case Variant::Sfm3003_300_CL:  return "SFM3003-300-CL";
        case Variant::Sfm3003_300_CE:  return "SFM3003-300-CE";
        case Variant::Sfm3013_300_CL:  return "SFM3013-300-CL";
        case Variant::Sfm3013_300_CLM: return "SFM3013-300-CLM";
        case Variant::Sfm3019_240:     return "SFM3019";
        case Variant::Sfm3119_240_CL:  return "SFM3119-240-CL";
    }
    return "?";
}
 
constexpr Family FamilyOf(Variant v) noexcept {
    switch (v) {
        case Variant::Sfm6000D_50:
        case Variant::Sfm6000D_20:
        case Variant::Sfm6000D_5:   return Family::Sfx6000;
        default:                    return Family::Sf06;
    }
}
 
constexpr Variant VariantFromProductId(uint32_t product_id) noexcept {
    switch (product_id & 0xFFFFFF00U) {
        case 0x06021100U: return Variant::Sfm6000D_50;
        case 0x06021200U: return Variant::Sfm6000D_20;
        case 0x06021400U: return Variant::Sfm6000D_5;
        default:          break;
    }
    /* SF06: 0x0403 <variant> <revision>. The low byte is a revision — parts
     * ship as 0x...1x and 0x...01 (an SFM4300-20-P read 0x04030301 on the
     * 2026-10-02 bench) — so it is ignored. */
    switch (product_id & 0xFFFFFF00U) {
        case 0x04030100U: return Variant::Sfm4300_20_B;
        case 0x04030200U: return Variant::Sfm4300_20_O;
        case 0x04030300U: return Variant::Sfm4300_20_P;
        case 0x04030900U: return Variant::Sfm4300_50_B;
        case 0x04030700U: return Variant::Sfm4300_50_O;
        case 0x04030600U: return Variant::Sfm4300_50_P;
        case 0x04020100U: return Variant::Sfm3003_300_CL;
        case 0x04020700U: return Variant::Sfm3003_300_CE;
        case 0x04020500U: return Variant::Sfm3013_300_CL;
        case 0x04020200U: return Variant::Sfm3013_300_CLM;
        case 0x04020600U: return Variant::Sfm3019_240;
        case 0x04040100U: return Variant::Sfm3119_240_CL;
        default:          return Variant::Unknown;
    }
}
 
constexpr float FullScaleSlm(Variant v) noexcept {
    switch (v) {
        case Variant::Sfm4300_20_B:
        case Variant::Sfm4300_20_O:
        case Variant::Sfm4300_20_P: return 20.0f;
        case Variant::Sfm4300_50_B:
        case Variant::Sfm4300_50_O:
        case Variant::Sfm4300_50_P: return 50.0f;
        case Variant::Sfm6000D_50:  return 50.0f;
        case Variant::Sfm6000D_20:  return 20.0f;
        case Variant::Sfm6000D_5:   return 5.0f;
        case Variant::Sfm3003_300_CL:
        case Variant::Sfm3003_300_CE:
        case Variant::Sfm3013_300_CL:
        case Variant::Sfm3013_300_CLM: return 300.0f;
        case Variant::Sfm3019_240:
        case Variant::Sfm3119_240_CL:  return 240.0f;
        case Variant::Unknown:      return 0.0f;
    }
    return 0.0f;
}
 
constexpr bool SupportsGas(Variant v, Gas g) noexcept {
    switch (v) {
        case Variant::Sfm4300_50_B:
        case Variant::Sfm4300_50_O:
        case Variant::Sfm4300_50_P:
        case Variant::Sfm3003_300_CL:
        case Variant::Sfm3003_300_CE:
        case Variant::Sfm3013_300_CL:
        case Variant::Sfm3019_240:
        case Variant::Sfm3119_240_CL:
            return g == Gas::O2 || g == Gas::Air || g == Gas::AirO2Mix;
        case Variant::Sfm3013_300_CLM:
            return g == Gas::O2 || g == Gas::Air || g == Gas::AirO2Mix || g == Gas::HeOx ||
                   g == Gas::HeOxO2Mix;
        case Variant::Sfm4300_20_B:
        case Variant::Sfm4300_20_O:
        case Variant::Sfm4300_20_P:
            return g != Gas::Ar && g != Gas::HeOx && g != Gas::HeOxO2Mix;
        case Variant::Sfm6000D_50:
        case Variant::Sfm6000D_20:
        case Variant::Sfm6000D_5:
            return g != Gas::N2OO2Mix && g != Gas::CO2O2Mix && g != Gas::HeOx &&
                   g != Gas::HeOxO2Mix;
        case Variant::Unknown:
            return g == Gas::O2 || g == Gas::Air;
    }
    return false;
}
 
constexpr bool GasNeedsKnownFamily(Gas g) noexcept {
    return g != Gas::O2 && g != Gas::Air;
}
 
struct ProductInfo {
    uint32_t product_id{0};
    uint8_t serial[8]{};
    Variant variant{Variant::Unknown};
};
 
struct Scaling {
    int16_t scale{1};       
    int16_t offset{0};      
    uint16_t unit{0};       
    int16_t full_scale_raw{0};  
    uint16_t gas_id{0};         
    bool valid{false};
 
    constexpr float FullScaleFlow() const noexcept {
        return full_scale_raw != 0 ? ToFlow(full_scale_raw) : 0.0f;
    }
 
    constexpr float ToFlow(int16_t raw) const noexcept {
        return scale != 0 ? (static_cast<float>(raw) - static_cast<float>(offset)) /
                                static_cast<float>(scale)
                          : 0.0f;
    }
};
 
struct StatusWord {
    uint16_t raw{0};
 
    constexpr uint8_t command_nibble() const noexcept { return static_cast<uint8_t>(raw >> 12); }
    constexpr bool exponential_smoothing() const noexcept { return (raw & (1U << 11)) != 0U; }
    constexpr bool fixed_n_averaging() const noexcept { return (raw & (1U << 10)) != 0U; }
    constexpr uint16_t gas_fraction_permille() const noexcept { return raw & 0x03FFU; }
    constexpr bool pure_gas() const noexcept {
        return gas_fraction_permille() == kStatusPureGasFraction;
    }
};
 
constexpr bool StatusNibbleIsKnown(Family family, uint8_t nibble) noexcept {
    const uint8_t n = nibble & 0x0FU;
    if (family == Family::Sfx6000) {
        return n <= 0x4U || n == 0xAU;
    }
    return n <= 0x3U || (n >= 0x6U && n <= 0x8U);
}
 
constexpr Gas GasFromStatusNibble(Family family, uint8_t nibble) noexcept {
    if (family == Family::Sfx6000) {
        switch (nibble & 0x0FU) {
            case 0x0: return Gas::O2;
            case 0x1: return Gas::Air;
            case 0x2: return Gas::CO2;
            case 0x3: return Gas::N2O;
            case 0x4: return Gas::Ar;
            case 0xA: return Gas::AirO2Mix;
            default:  return Gas::Air;
        }
    }
    switch (nibble & 0x0FU) {
        case 0x0: return Gas::O2;
        case 0x1: return Gas::Air;
        case 0x2: return Gas::N2O;
        case 0x3: return Gas::CO2;
        case 0x6: return Gas::AirO2Mix;
        case 0x7: return Gas::N2OO2Mix;
        case 0x8: return Gas::CO2O2Mix;
        default:  return Gas::Air;  // 4, 5 reserved; 9 to 15 unused
    }
}
 
static_assert(GasFromStatusNibble(Family::Sf06, 0x6) == Gas::AirO2Mix,
              "SFM4300 data sheet Table 5: Air/O2 (0x3632) reports 0b0110");
 
constexpr Gas GasFromStatusNibble(Variant variant, uint8_t nibble) noexcept {
    if (variant == Variant::Sfm3013_300_CLM) {
        if ((nibble & 0x0FU) == 0x2U) {
            return Gas::HeOx;
        }
        if ((nibble & 0x0FU) == 0x7U) {
            return Gas::HeOxO2Mix;
        }
    }
    return GasFromStatusNibble(FamilyOf(variant), nibble);
}
 
struct Measurement {
    int16_t flow_raw{0};
    int16_t temperature_raw{0};
    StatusWord status{};
    float flow{0.0f};           
    float temperature_c{0.0f};  
    bool temperature_valid{true};  
};
 
}  // namespace sfm