unit_Light.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_LIGHT_UNIT_LIGHT_HPP
#define M5_UNIT_LIGHT_UNIT_LIGHT_HPP
 
#include <cstdint>
#include <limits>
#include <memory>  // std::unique_ptr
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
 
#include "unit_Light_data.hpp"  // Data (with inline normalized())
 
namespace m5 {
namespace unit {
 
class UnitLight : public Component, public PeriodicMeasurementAdapter<UnitLight, light::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitLight, 0x00);
 
public:
    struct config_t {
        bool start_periodic{true};
        uint32_t interval_ms{light::DEFAULT_INTERVAL_MS};
        uint16_t dark{light::DEFAULT_DARK};
        uint16_t bright{light::DEFAULT_BRIGHT};
    };
 
    explicit UnitLight(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<light::Data>(1)}
    {
        auto ccfg        = component_config();
        ccfg.stored_size = 1;
        component_config(ccfg);
    }
    virtual ~UnitLight()
    {
    }
 
    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 uint16_t analog() const
    {
        return !empty() ? latest().analog_raw : 0;
    }
    inline bool digital() const
    {
        return !empty() ? latest().digital : false;
    }
    inline float normalized() const
    {
        if (empty()) {
            return std::numeric_limits<float>::quiet_NaN();
        }
        light::Data d{latest()};
        d.dark   = _dark;
        d.bright = _bright;
        return d.normalized();
    }
 
 
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitLight, light::Data>::startPeriodicMeasurement();
    }
    inline bool startPeriodicMeasurement(const uint32_t interval_ms)
    {
        return PeriodicMeasurementAdapter<UnitLight, light::Data>::startPeriodicMeasurement(interval_ms);
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitLight, light::Data>::stopPeriodicMeasurement();
    }
 
 
    bool calibrateDark();
    bool calibrateBright();
    void setCalibration(const uint16_t dark, const uint16_t bright);
    void resetCalibration();
 
    inline uint16_t dark() const
    {
        return _dark;
    }
    inline uint16_t bright() const
    {
        return _bright;
    }
 
protected:
    bool start_periodic_measurement();
    bool start_periodic_measurement(const uint32_t interval_ms);
    bool stop_periodic_measurement();
 
    bool read_measurement(light::Data& data);
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitLight, light::Data);
 
protected:
    std::unique_ptr<m5::container::CircularBuffer<light::Data>> _data{};
    config_t _cfg{};
    uint16_t _dark{light::DEFAULT_DARK};
    uint16_t _bright{light::DEFAULT_BRIGHT};
};
 
}  // namespace unit
}  // namespace m5
 
#endif