AlicatBasis2Handler.h

Go to the documentation of this file.

 
#ifndef COMPONENT_HANDLER_ALICAT_BASIS2_HANDLER_H_
#define COMPONENT_HANDLER_ALICAT_BASIS2_HANDLER_H_
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
 
#include "RtosMutex.h"
#include "base/BaseUart.h"
 
#include "core/hf-core-drivers/external/hf-alicat-basis2-driver/inc/alicat_basis2.hpp"
#include "core/hf-core-drivers/external/hf-alicat-basis2-driver/inc/alicat_basis2_uart_interface.hpp"
 
//==============================================================================
// CRTP UART ADAPTER FOR BaseUart
//==============================================================================
 
class HalUartAlicatBasis2Comm
    : public alicat_basis2::UartInterface<HalUartAlicatBasis2Comm> {
public:
    explicit HalUartAlicatBasis2Comm(BaseUart& uart) noexcept : uart_(uart) {}
 
    void write(const std::uint8_t* data, std::size_t length) noexcept;
    std::size_t read(std::uint8_t* out, std::size_t max,
                     std::uint32_t timeout_ms) noexcept;
    void flush_rx() noexcept;
    void delay_ms_impl(std::uint32_t ms) noexcept;
 
private:
    BaseUart& uart_;
};
 
//==============================================================================
// HANDLER CONFIGURATION
//==============================================================================
 
struct AlicatBasis2HandlerConfig {
    std::uint8_t  modbus_address{1};       
    std::uint16_t timeout_ms{200};          
    std::uint8_t  device_index{0};          
    std::uint8_t  flow_decimals_default{3};
};
 
inline constexpr AlicatBasis2HandlerConfig MakeDefaultBasis2Config(std::uint8_t addr,
                                                                   std::uint8_t idx) noexcept {
    AlicatBasis2HandlerConfig c{};
    c.modbus_address       = addr;
    c.timeout_ms           = 200;
    c.device_index         = idx;
    c.flow_decimals_default = 3;
    return c;
}
 
//==============================================================================
// HANDLER CLASS
//==============================================================================
 
class AlicatBasis2Handler {
public:
    using DriverType = alicat_basis2::Driver<HalUartAlicatBasis2Comm>;
 
    AlicatBasis2Handler(BaseUart& uart,
                        const AlicatBasis2HandlerConfig& config,
                        RtosMutex* bus_mutex = nullptr) noexcept;
 
    AlicatBasis2Handler(const AlicatBasis2Handler&)            = delete;
    AlicatBasis2Handler& operator=(const AlicatBasis2Handler&) = delete;
 
    bool EnsureInitialized() noexcept;
    bool IsInitialized() const noexcept { return initialized_.load(std::memory_order_acquire); }
 
    std::uint8_t Address() const noexcept     { return config_.modbus_address; }
    std::uint8_t DeviceIndex() const noexcept { return config_.device_index; }
 
    const alicat_basis2::InstrumentIdentity& Identity() const noexcept { return identity_; }
    std::uint8_t FlowDecimals() const noexcept { return flow_decimals_; }
 
    //--------------------------------------------------------------------------
    // High-level operations (mutex-guarded)
    //--------------------------------------------------------------------------
 
    alicat_basis2::DriverResult<alicat_basis2::InstantaneousData>
    ReadInstantaneous() noexcept;
 
    alicat_basis2::DriverResult<alicat_basis2::InstrumentIdentity>
    RereadIdentity() noexcept;
 
    alicat_basis2::DriverResult<void> Tare() noexcept;
    alicat_basis2::DriverResult<void> SetGas(alicat_basis2::Gas g) noexcept;
    alicat_basis2::DriverResult<void> SetSetpoint(float user_units) noexcept;
    alicat_basis2::DriverResult<void> SetSetpointSource(alicat_basis2::SetpointSource s) noexcept;
    alicat_basis2::DriverResult<void> SetCommWatchdogMs(std::uint16_t ms) noexcept;
    alicat_basis2::DriverResult<void> SetMaxSetpointRamp(std::uint32_t pct_per_ms_x_10e7) noexcept;
    alicat_basis2::DriverResult<void> SetAutotareEnabled(bool enabled) noexcept;
    alicat_basis2::DriverResult<void> ResetTotalizer() noexcept;
    alicat_basis2::DriverResult<void> SetTotalizerLimitMode(alicat_basis2::TotalizerLimitMode m) noexcept;
    alicat_basis2::DriverResult<void> SetTotalizerBatch(std::uint32_t value_scaled) noexcept;
    alicat_basis2::DriverResult<void> SetFlowAveragingMs(std::uint16_t ms) noexcept;
    alicat_basis2::DriverResult<void> SetReferenceTemperatureC(float c) noexcept;
    alicat_basis2::DriverResult<void> ConfigureMeasurementTrigger(std::uint16_t bits) noexcept;
    alicat_basis2::DriverResult<void> StartMeasurementSamples(std::uint16_t n) noexcept;
    alicat_basis2::DriverResult<alicat_basis2::MeasurementData> ReadMeasurement() noexcept;
    alicat_basis2::DriverResult<void> SetModbusAddress(std::uint8_t addr) noexcept;
    alicat_basis2::DriverResult<void> SetAsciiUnitId(char id) noexcept;
    alicat_basis2::DriverResult<void> SetBaudRate(alicat_basis2::BaudRate br) noexcept;
    alicat_basis2::DriverResult<void> FactoryRestore() noexcept;
 
    alicat_basis2::DriverResult<std::uint8_t>
    Discover(std::uint8_t* present_bitmap, std::size_t bitmap_bytes,
             std::uint16_t probe_timeout_ms = 30) noexcept;
 
    //--------------------------------------------------------------------------
    // Multi-baud discovery + bus normalisation
    //--------------------------------------------------------------------------
 
    struct DiscoveredDevice {
        std::uint8_t  address{0};        
        std::uint32_t baud_bps{0};       
    };
 
    using HostBaudSetter = std::function<bool(std::uint32_t bps)>;
 
    alicat_basis2::DriverResult<std::size_t>
    DiscoverAcrossBauds(DiscoveredDevice*       out,
                        std::size_t             max_devices,
                        const HostBaudSetter&   set_host_baud,
                        std::uint16_t           probe_timeout_ms = 30,
                        std::uint32_t           settle_ms        = 25,
                        const std::uint32_t*    baud_list_bps    = nullptr,
                        std::size_t             baud_list_count  = 0) noexcept;
 
    alicat_basis2::DriverResult<std::size_t>
    NormalizeBusBaud(std::uint32_t           target_bps,
                     const DiscoveredDevice* devices,
                     std::size_t             device_count,
                     const HostBaudSetter&   set_host_baud,
                     std::uint8_t*           failed_addresses_bitmap = nullptr,
                     std::size_t             failed_bitmap_bytes     = 0,
                     std::uint16_t           verify_timeout_ms       = 100) noexcept;
 
    DriverType* GetDriver() noexcept { return driver_.get(); }
 
private:
    AlicatBasis2HandlerConfig          config_;
    HalUartAlicatBasis2Comm            comm_;
    std::unique_ptr<DriverType>        driver_;
    alicat_basis2::InstrumentIdentity  identity_{};
    std::uint8_t                       flow_decimals_{3};
 
    std::atomic<bool>                  initialized_{false};
 
    RtosMutex                          private_mutex_;
    RtosMutex*                         bus_mutex_{&private_mutex_};
 
    bool EnsureInitializedLocked() noexcept;
};
 
#endif  // COMPONENT_HANDLER_ALICAT_BASIS2_HANDLER_H_