unit_TCS3472x_data.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_DATA_HPP
#define M5_UNIT_COLOR_UNIT_TCS3472X_DATA_HPP
 
#include <algorithm>
#include <array>
#include <cstdint>
 
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(const 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(const uint8_t r, const uint8_t g, const uint8_t b)
    {
        return ((((r >> 5) << 3) + (g >> 5)) << 2) + (b >> 6);
    }
    inline static constexpr uint16_t color565(const uint8_t r, const uint8_t g, const uint8_t b)
    {
        return (r >> 3) << 11 | (g >> 2) << 5 | b >> 3;
    }
    inline static constexpr uint32_t color888(const uint8_t r, const uint8_t g, const uint8_t b)
    {
        return r << 16 | g << 8 | b;
    }
    inline static constexpr uint16_t swap565(const uint8_t r, const uint8_t g, const uint8_t b)
    {
        return (((r >> 3) << 3) + (g >> 5)) | (((g >> 2) << 5) | (b >> 3)) << 8;
    }
    inline static constexpr uint32_t swap888(const uint8_t r, const uint8_t g, const 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
 
}  // namespace unit
}  // namespace m5
#endif