unit_VL53L0X.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_TOF_UNIT_VL53L0X_HPP
#define M5_UNIT_TOF_UNIT_VL53L0X_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <m5_utility/types.hpp>
#include <array>
#include <limits>  // NaN
 
namespace m5 {
namespace unit {
namespace vl53l0x {
enum class Operating : uint8_t {
    ConditionStandard,  
    Condition2V8        
};
 
enum class Mode : int8_t {
    Unknown = -1,
    Default,       
    HighAccuracy,  
    LongRange,     
    HighSpeed,     
};
 
enum class RangeStatus : uint8_t {
    OK,
    HardwareFailure,
    PhaseFailure,
    MinRangeFailure,
    SignalFailure,
    SigmaFailure,
    Unknown = 255
};
 
struct Data {
    std::array<uint8_t, 12> raw{};  
    RangeStatus range_status() const;
    inline bool valid() const
    {
        return ((raw[0] & 0x78) >> 3) == 11;
    }
    inline int16_t range() const
    {
        return valid() ? m5::types::big_uint16_t(raw[10], raw[11]).get() : -1;
    }
};
 
}  // namespace vl53l0x
 
class UnitVL53L0X : public Component, public PeriodicMeasurementAdapter<UnitVL53L0X, vl53l0x::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitVL53L0X, 0x29);
 
public:
    struct config_t {
        vl53l0x::Operating operating{vl53l0x::Operating::Condition2V8};
        vl53l0x::Mode mode{vl53l0x::Mode::LongRange};
        bool start_periodic{true};
    };
 
    explicit UnitVL53L0X(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<vl53l0x::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitVL53L0X()
    {
    }
 
    virtual bool begin() override;
    virtual void update(const bool force = false) override;
 
 
    inline config_t config() const
    {
        return _cfg;
    }
    inline void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
 
    inline int16_t range() const
    {
        return !empty() ? oldest().range() : -1;
    }
    inline bool valid() const
    {
        return !empty() && oldest().valid();
    }
    inline vl53l0x::RangeStatus range_status() const
    {
        return !empty() ? oldest().range_status() : vl53l0x::RangeStatus::Unknown;
    }
 
 
    vl53l0x::Mode mode() const
    {
        return _mode;
    }
 
 
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitVL53L0X, vl53l0x::Data>::startPeriodicMeasurement();
    }
    inline bool startPeriodicMeasurement(const vl53l0x::Mode mode)
    {
        return PeriodicMeasurementAdapter<UnitVL53L0X, vl53l0x::Data>::startPeriodicMeasurement(mode);
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitVL53L0X, vl53l0x::Data>::stopPeriodicMeasurement();
    }
 
 
    bool measureSingleshot(vl53l0x::Data& d);
 
    bool softReset();
 
    bool writeMode(const vl53l0x::Mode mode);
 
 
    bool readSignalRateLimit(float& mcps);
    bool writeSignalRateLimit(const float mcps);
 
 
    bool readI2CAddress(uint8_t& i2c_address);
    bool changeI2CAddress(const uint8_t i2c_address);
 
protected:
    bool start_periodic_measurement();
    inline bool start_periodic_measurement(const vl53l0x::Mode mode)
    {
        return writeMode(mode) && start_periodic_measurement();
    }
    bool stop_periodic_measurement();
 
    bool read_data_ready_status();
    bool read_measurement(vl53l0x::Data& d);
 
    bool write_default_values();
    bool perform_single_ref_calibration(bool VHV);
    bool write_vcsel_period_range(const uint8_t pre_pclk, const uint8_t final_pclk);
 
    bool soft_reset();
 
    bool write_default_settings();
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitVL53L0X, vl53l0x::Data);
 
protected:
    vl53l0x::Mode _mode{vl53l0x::Mode::Unknown};
    uint8_t _stop{};  // stop variable
    std::unique_ptr<m5::container::CircularBuffer<vl53l0x::Data>> _data{};
    config_t _cfg{};
};
 
namespace vl53l0x {
namespace command {
constexpr uint8_t SYSTEM_RANGE_START{0x00};
constexpr uint8_t SYSTEM_SEQUENCE_CONFIG{0x01};
constexpr uint8_t SYSTEM_INTERMEASUREMENT_PERIOD{0x04};
constexpr uint8_t SYSTEM_INTERRUPT_CONFIG_GPIO{0x0A};
constexpr uint8_t SYSTEM_INTERRUPT_CLEAR{0x0B};
constexpr uint8_t RESULT_INTERRUPT_STATUS{0x13};
constexpr uint8_t RESULT_RANGE_STATUS{0x14};
constexpr uint8_t RESULT_RANGE_STATUS_RESULT{0x1E};
constexpr uint8_t ALGO_PHASECAL_CONFIG_TIMEOUT{0x30};
constexpr uint8_t GLOBAL_CONFIG_VCSEL_WIDTH{0x32};
constexpr uint8_t FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT{0x44};
constexpr uint8_t MSRC_CONFIG_TIMEOUT_MACROP{0x46};
constexpr uint8_t FINAL_RANGE_CONFIG_VALID_PHASE_LOW{0x47};
constexpr uint8_t FINAL_RANGE_CONFIG_VALID_PHASE_HIGH{0x48};
constexpr uint8_t PRE_RANGE_CONFIG_VCSEL_PERIOD{0x50};
constexpr uint8_t PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI{0x51};
constexpr uint8_t PRE_RANGE_CONFIG_VALID_PHASE_LOW{0x56};
constexpr uint8_t PRE_RANGE_CONFIG_VALID_PHASE_HIGH{0x57};
constexpr uint8_t MSRC_CONFIG_CONTROL{0x60};
 
constexpr uint8_t FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI{0x71};
constexpr uint8_t GPIO_HV_MUX_ACTIVE_HIGH{0x84};
constexpr uint8_t I2C_SLAVE_DEVICE_ADDRESS{0x8A};
constexpr uint8_t VHV_CONFIG_PAD_SCL_SDA_EXTSUP_HV{0x89};
constexpr uint8_t SOFT_RESET{0xBF};
constexpr uint8_t MODEL_ID{0xC0};
 
constexpr uint8_t ALGO_PHASECAL_LIM{0x30};
}  // namespace command
}  // namespace vl53l0x
 
}  // namespace unit
}  // namespace m5
#endif