unit_TCS3472x.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_COLOR_UNIT_TCS3472X_HPP
#define M5_UNIT_COLOR_UNIT_TCS3472X_HPP
 
#include "unit_TCS3472x_data.hpp"
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <array>
 
namespace m5 {
namespace unit {
 
class UnitTCS3472x : public Component, public PeriodicMeasurementAdapter<UnitTCS3472x, tcs3472x::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitTCS3472x, 0x00);
 
public:
    struct config_t {
        bool start_periodic{true};
        float atime{614.4f};
        float wtime{2.4f};
        tcs3472x::Gain gain{tcs3472x::Gain::Controlx4};
    };
 
    explicit UnitTCS3472x(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<tcs3472x::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitTCS3472x()
    {
    }
 
    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 uint8_t R8() const
    {
        return !empty() ? oldest().R8() : 0U;
    }
    inline uint8_t G8() const
    {
        return !empty() ? oldest().G8() : 0U;
    }
    inline uint8_t B8() const
    {
        return !empty() ? oldest().B8() : 0U;
    }
    inline uint16_t RGB565() const
    {
        return !empty() ? oldest().RGB565() : 0U;
    }
 
 
    bool readPersistence(tcs3472x::Persistence& pers);
    bool writePersistence(const tcs3472x::Persistence pers);
    bool readGain(tcs3472x::Gain& gc);
    bool writeGain(const tcs3472x::Gain gc);
    bool readAtime(uint8_t& raw);
    bool readAtime(float& ms);
    template <typename T, typename std::enable_if<std::is_integral<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeAtime(const T raw)
    {
        return write_atime(static_cast<uint8_t>(raw));
    }
    bool writeAtime(const float ms);
    bool readWtime(uint8_t& raw, bool& wlong);
    bool readWtime(float& ms);
    bool writeWtime(const uint8_t raw, const bool wlong);
    bool writeWtime(const float ms);
 
 
    inline bool startPeriodicMeasurement(const tcs3472x::Gain gc, const float atime, const float wtime)
    {
        return PeriodicMeasurementAdapter<UnitTCS3472x, tcs3472x::Data>::startPeriodicMeasurement(gc, atime, wtime);
    }
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitTCS3472x, tcs3472x::Data>::startPeriodicMeasurement();
    }
    inline bool stopPeriodicMeasurement(const bool power_off = true)
    {
        return PeriodicMeasurementAdapter<UnitTCS3472x, tcs3472x::Data>::stopPeriodicMeasurement(power_off);
    }
 
 
    bool measureSingleshot(tcs3472x::Data& d, const tcs3472x::Gain gc, const float atime);
    bool measureSingleshot(tcs3472x::Data& d);
 
 
    bool readInterrupt(bool& enable);
    bool writeInterrupt(const bool enable);
    bool readInterruptThreshold(uint16_t& low, uint16_t& high);
    bool writeInterruptThreshold(const uint16_t low, const uint16_t high);
 
    bool clearInterrupt();
 
    bool readStatus(uint8_t& status);
 
protected:
    inline virtual bool is_valid_id(const uint8_t /*id*/) const
    {
        return false;
    }
 
    bool read_register8(const uint8_t reg, uint8_t& val);
    bool write_register8(const uint8_t reg, const uint8_t val);
    bool read_register(const uint8_t reg, uint8_t* buf, const uint32_t len);
    bool write_register(const uint8_t reg, const uint8_t* buf, const uint32_t len);
 
    bool start_periodic_measurement(const tcs3472x::Gain gc, const float atime, const float wtime);
    bool start_periodic_measurement();
    bool stop_periodic_measurement(const bool power_off);
 
    bool is_data_ready();
    bool read_measurement(tcs3472x::Data& d);
 
    bool write_atime(const uint8_t raw);
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitTCS3472x, tcs3472x::Data);
 
private:
    std::unique_ptr<m5::container::CircularBuffer<tcs3472x::Data>> _data{};
    config_t _cfg{};
};
 
class UnitTCS34725 : public UnitTCS3472x {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitTCS34725, 0x29);
 
public:
    explicit UnitTCS34725(const uint8_t addr = DEFAULT_ADDRESS) : UnitTCS3472x(addr)
    {
    }
    virtual ~UnitTCS34725()
    {
    }
    static constexpr uint8_t UNIT_ID{0x44};
 
protected:
    inline virtual bool is_valid_id(const uint8_t id) const override
    {
        return id == UNIT_ID;
    }
};
 
class UnitTCS34727 : public UnitTCS3472x {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitTCS34727, 0x29);
 
public:
    explicit UnitTCS34727(const uint8_t addr = DEFAULT_ADDRESS) : UnitTCS3472x(addr)
    {
    }
    virtual ~UnitTCS34727()
    {
    }
    static constexpr uint8_t UNIT_ID{0x4D};
 
protected:
    inline virtual bool is_valid_id(const uint8_t id) const override
    {
        return id == UNIT_ID;
    }
};
 
namespace tcs3472x {
namespace command {
// R/W
constexpr uint8_t ENABLE_REG{0x00};
constexpr uint8_t ATIME_REG{0x01};
constexpr uint8_t WTIME_REG{0x03};
constexpr uint8_t AILTL_REG{0x04};
constexpr uint8_t AILTH_REG{0x05};
constexpr uint8_t AIHTL_REG{0x06};
constexpr uint8_t AIHTH_REG{0x07};
constexpr uint8_t PERS_REG{0x0C};
constexpr uint8_t CONFIG_REG{0x0D};
constexpr uint8_t CONTROL_REG{0x0F};
// R
constexpr uint8_t ID_REG{0x12};
constexpr uint8_t STATUS_REG{0x13};
constexpr uint8_t CDATAL_REG{0x14};
constexpr uint8_t CDATAH_REG{0x15};
constexpr uint8_t RDATAL_REG{0x16};
constexpr uint8_t RDATAH_REG{0x17};
constexpr uint8_t GDATAL_REG{0x18};
constexpr uint8_t GDATAH_REG{0x19};
constexpr uint8_t BDATAL_REG{0x1A};
constexpr uint8_t BDATAH_REG{0x1B};
 
}  // namespace command
}  // namespace tcs3472x
 
}  // namespace unit
}  // namespace m5
#endif