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_TCS3472_HPP
#define M5_UNIT_COLOR_UNIT_TCS3472_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <array>
 
namespace m5 {
namespace unit {
 
namespace tcs3472x {
 
enum class Persistence : uint8_t {
    Every,    
    Cycle1,   
    Cycle2,   
    Cycle3,   
    Cycle5,   
    Cycle10,  
    Cycle15,  
    Cycle20,  
    Cycle25,  
    Cycle30,  
    Cycle35,  
    Cycle40,  
    Cycle45,  
    Cycle50,  
    Cycle55,  
    Cycle60,  
};
 
enum class Gain : uint8_t {
    Controlx1,   
    Controlx4,   
    Controlx16,  
    Controlx60,  
};
 
struct Data {
    std::array<uint8_t, 8> raw{};  
 
    inline uint16_t R16() const
    {
        return (static_cast<uint16_t>(raw[3]) << 8) | raw[2];
    }
    inline uint16_t G16() const
    {
        return (static_cast<uint16_t>(raw[5]) << 8) | raw[4];
    }
    inline uint16_t B16() const
    {
        return (static_cast<uint16_t>(raw[7]) << 8) | raw[6];
    }
    inline uint16_t C16() const
    {
        return (static_cast<uint16_t>(raw[1]) << 8) | raw[0];
    }
    inline uint16_t RnoIR16() const
    {
        return std::max(std::min(R16() - IR(), static_cast<int32_t>(0xFFFF)), static_cast<int32_t>(0x0000));
    }
    inline uint16_t GnoIR16() const
    {
        return std::max(std::min(G16() - IR(), static_cast<int32_t>(0xFFFF)), static_cast<int32_t>(0x0000));
    }
    inline uint16_t BnoIR16() const
    {
        return std::max(std::min(B16() - IR(), static_cast<int32_t>(0xFFFF)), static_cast<int32_t>(0x0000));
    }
    inline uint16_t CnoIR16() const
    {
        return std::max(std::min(C16() - IR(), static_cast<int32_t>(0xFFFF)), static_cast<int32_t>(0x0000));
    }
 
    inline uint8_t R8() const
    {
        return raw_to_uint8(R16(), C16());
    }
    inline uint8_t G8() const
    {
        return raw_to_uint8(G16(), C16());
    }
    inline uint8_t B8() const
    {
        return raw_to_uint8(B16(), C16());
    }
    inline uint8_t RnoIR8() const
    {
        return raw_to_uint8(RnoIR16(), CnoIR16());
    }
    inline uint8_t GnoIR8() const
    {
        return raw_to_uint8(GnoIR16(), CnoIR16());
    }
    inline uint8_t BnoIR8() const
    {
        return raw_to_uint8(BnoIR16(), CnoIR16());
    }
 
    inline uint16_t RGB565() const
    {
        return color565(R8(), G8(), B8());
    }
    inline uint32_t RGB888() const
    {
        return color888(R8(), G8(), B8());
    }
    inline uint16_t RGBnoIR565() const
    {
        return color565(RnoIR8(), GnoIR8(), BnoIR8());
    }
    inline uint32_t RGBnoIR888() const
    {
        return color888(RnoIR8(), GnoIR8(), BnoIR8());
    }
 
    inline int32_t IR(bool usingCache = true) const
    {
        if (!usingCache || !_cacheValid) {
            _cache      = static_cast<int32_t>((static_cast<int32_t>(R16()) + static_cast<int32_t>(G16()) +
                                           static_cast<int32_t>(B16()) - static_cast<int32_t>(C16())) *
                                          0.5f);
            _cacheValid = true;
        }
        return _cache;
    }
 
    inline static uint8_t raw_to_uint8(const int32_t v, const int32_t c)
    {
        return std::max(std::min(static_cast<int>(c ? (static_cast<float>(v) / c) * 255.f : 0), 0xFF), 0x00);
    }
 
    inline static constexpr uint8_t color332(uint8_t r, uint8_t g, uint8_t b)
    {
        return ((((r >> 5) << 3) + (g >> 5)) << 2) + (b >> 6);
    }
    inline static constexpr uint16_t color565(uint8_t r, uint8_t g, uint8_t b)
    {
        return (r >> 3) << 11 | (g >> 2) << 5 | b >> 3;
    }
    inline static constexpr uint32_t color888(uint8_t r, uint8_t g, uint8_t b)
    {
        return r << 16 | g << 8 | b;
    }
    inline static constexpr uint16_t swap565(uint8_t r, uint8_t g, uint8_t b)
    {
        return (((r >> 3) << 3) + (g >> 5)) | (((g >> 2) << 5) | (b >> 3)) << 8;
    }
    inline static constexpr uint32_t swap888(uint8_t r, uint8_t g, uint8_t b)
    {
        return b << 16 | g << 8 | r;
    }
 
private:
    mutable int32_t _cache{};    // IR component value cache
    mutable bool _cacheValid{};  // True if _cache holds a computed value
};
 
}  // namespace tcs3472x
 
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()
    {
        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)
    {
        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_register16(const uint8_t reg, uint16_t& val);
    // bool write_register16(const uint8_t reg, const uint16_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) 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) 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