SfmHandler.h

Go to the documentation of this file.

 
#ifndef COMPONENT_HANDLER_SFM_HANDLER_H_
#define COMPONENT_HANDLER_SFM_HANDLER_H_
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <memory>
 
#include "base/BaseI2c.h"
#include "core/hf-core-drivers/external/hf-sfm-flow-meter-driver/inc/sfm.hpp"
#include "RtosMutex.h"
 
//==============================================================================
// CRTP I2C ADAPTER
//==============================================================================
 
class HalI2cSfmComm : public sfm::I2cInterface<HalI2cSfmComm> {
public:
    explicit HalI2cSfmComm(BaseI2c& i2c_device) noexcept;
 
    bool Write(std::uint8_t addr7, const std::uint8_t* data, std::size_t len) noexcept;
    bool Read(std::uint8_t addr7, std::uint8_t* out, std::size_t len) noexcept;
    void DelayMs(std::uint32_t ms) noexcept;
    bool EnsureInitialized() noexcept;
 
    [[nodiscard]] std::uint8_t DeviceAddress() const noexcept;
 
private:
    BaseI2c& i2c_device_;
    std::uint8_t tx_scratch_[8]{};
    std::uint8_t rx_scratch_[18]{};
};
 
//==============================================================================
// HANDLER CONFIGURATION
//==============================================================================
 
struct SfmHandlerConfig {
    sfm::Gas default_gas{sfm::Gas::Air};
    std::uint16_t o2_permille{0};
    std::uint16_t averaging_window{0};
    bool soft_reset_on_init{false};
    std::uint8_t device_index{0};
};
 
//==============================================================================
// HANDLER
//==============================================================================
 
class SfmHandler {
public:
    using DriverType = sfm::Driver<HalI2cSfmComm>;
 
    explicit SfmHandler(BaseI2c& i2c_device,
                        const SfmHandlerConfig& config = SfmHandlerConfig{},
                        RtosMutex* bus_mutex = nullptr) noexcept;
 
    SfmHandler(const SfmHandler&) = delete;
    SfmHandler& operator=(const SfmHandler&) = delete;
    SfmHandler(SfmHandler&&) = delete;
    SfmHandler& operator=(SfmHandler&&) = delete;
 
    bool EnsureInitialized() noexcept;
 
    void Invalidate() noexcept { initialized_.store(false, std::memory_order_release); }
 
    [[nodiscard]] bool IsPresent() const noexcept {
        return initialized_.load(std::memory_order_acquire);
    }
 
    [[nodiscard]] const sfm::ProductInfo& Identity() const noexcept { return identity_; }
 
    [[nodiscard]] bool SupportsGas(sfm::Gas gas) const noexcept;
 
    [[nodiscard]] float FullScaleSlm() const noexcept;
 
    //==========================================================================
    // Measurement session
    //==========================================================================
 
    sfm::DriverResult<void> Start(sfm::Gas gas) noexcept;
 
    sfm::DriverResult<void> Start() noexcept { return Start(config_.default_gas); }
 
    sfm::DriverResult<void> Stop() noexcept;
 
    sfm::DriverResult<sfm::Measurement> ReadMeasurement() noexcept;
 
    sfm::DriverResult<void> ConfigureAveraging(std::uint16_t window) noexcept;
 
    sfm::DriverResult<void> UpdateConcentration(std::uint16_t o2_permille) noexcept;
 
    sfm::DriverResult<float> ReadTemperature() noexcept;
 
    sfm::DriverResult<sfm::Measurement> DecodeFrame(const std::uint8_t frame[9]) noexcept;
 
    [[nodiscard]] sfm::Family Family() const noexcept;
 
    [[nodiscard]] std::uint8_t Address() const noexcept { return comm_.DeviceAddress(); }
 
    [[nodiscard]] sfm::Gas ActiveGas() const noexcept;
    [[nodiscard]] sfm::Scaling ActiveScaling() const noexcept;
    [[nodiscard]] bool Measuring() const noexcept;
 
    struct Counters {
        std::uint32_t frames{0};
        std::uint32_t no_data{0};
        std::uint32_t crc_errors{0};
        std::uint32_t bus_errors{0};
    };
    [[nodiscard]] Counters GetCounters() const noexcept;
 
private:
    bool EnsureInitializedLocked() noexcept;
 
    SfmHandlerConfig config_;
    HalI2cSfmComm comm_;
    std::unique_ptr<DriverType> driver_;
 
    sfm::ProductInfo identity_{};
    std::atomic<bool> initialized_{false};
 
    std::atomic<std::uint32_t> frames_{0};
    std::atomic<std::uint32_t> no_data_{0};
    std::atomic<std::uint32_t> crc_errors_{0};
    std::atomic<std::uint32_t> bus_errors_{0};
 
    RtosMutex private_mutex_;
    RtosMutex* bus_mutex_;
};
 
#endif  // COMPONENT_HANDLER_SFM_HANDLER_H_