color_sensor.hpp

Go to the documentation of this file.

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  *  _____.___.                 .___                    .__.__      *
  *  \__  |   | ____   ____   __| _/___________    _____|__|  |     *
  *   /   |   |/ ___\ / ___\ / __ |\_  __ \__  \  /  ___/  |  |     *
  *   \____   / /_/  > /_/  > /_/ | |  | \// __ \_\___ \|  |  |__   *
  *   / ______\___  /\___  /\____ | |__|  (____  /____  >__|____/   *
  *   \/     /_____//_____/      \/            \/     \/            *
  *                         - Yggdrasil -                           *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * This software can be used by students and other personal of the *
  * Bern University of Applied Sciences under the terms of the MIT  *
  * license.                                                        *
  * For other persons this software is under the terms of the GNU   *
  * General Public License version 2.                               *
  *                                                                 *
  * Copyright © 2021, Bern University of Applied Sciences.     *
  * All rights reserved.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#pragma once
 
#include <cpp/common/attributes.hpp>
#include <cpp/common/types.hpp>
#include <cpp/common/utils.hpp>
 
namespace bsp::ygg::prph {
 
    class ColorSensor {
    public:
        ColorSensor() = delete;
 
        enum class IntegrationTime {
            _2_4ms  = 0xFF, 
            _10ms   = 0xFB, 
            _24ms   = 0xF6, 
            _50ms   = 0xEB, 
            _101ms  = 0xD5, 
            _154ms  = 0xC0, 
            _700ms  = 0x00  
        };
 
        enum class Gain {
          _1x   = 0x00, 
          _4x   = 0x01, 
          _16x  = 0x02, 
          _60x  = 0x03  
        };
 
        static bool init() {
            u8 retries = 0;
            do{
                if(bsp::I2CA::read<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::ID)) != DeviceID){  // Check device id
                    core::delay(1);
                    retries++;
                    if(retries > 10) return false;
                }
                else{
                    break;
                }
            }
            while(true);
 
 
 
            setIntergrationTime(IntegrationTime::_2_4ms);           // Set integration time
            setGain(Gain::_1x);                                     // Set gain
            enable();                                               // Enable sensor
            startConversion();                                      // Start a conversion
 
            core::delay(3);                                         // Wait for the conversion to complete
 
            return true;
 
        }
 
 
        static inline void setIntergrationTime(IntegrationTime integrationTime) {
            ColorSensor::s_integrationTime = enumValue(integrationTime);
            bsp::I2CA::write<u8>(DeviceAddress, enumValue(RegisterID::ATIME),  enumValue(integrationTime)); // Write integration time in the ATIME register
        }
 
        static inline void setGain(Gain gain) {
            bsp::I2CA::write<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::CTRL), enumValue(gain));             // Set gain value in the CTRL register
        }
 
        static void enable() {
            EnableRegister enRegister = { 0 };
            enRegister.PON = 1;
 
            bsp::I2CA::write<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::EN), bit_cast<u8>(enRegister));      // Enable sensor
 
            core::delay(3);                                                                                             // Wait for power up
        }
 
        static void disable() {
            EnableRegister enRegister = { 0 };
            bsp::I2CA::write<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::EN), bit_cast<u8>(enRegister));      // Disable sensor
        }
 
        static u16 startConversion() {
            EnableRegister enRegister = { 0 };
 
            enRegister.PON = 1;                                                                                     // Enable
            enRegister.AEN = 1;                                                                                     // Enable RGBC
            bsp::I2CA::write<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::EN), bit_cast<u8>(enRegister));  // Write enable register
 
            return static_cast<u16>((256 - ColorSensor::s_integrationTime) * 2.4F + 0.9);
        }
 
 
        static bool isDone() {
            return (bsp::I2CA::read<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::STATUS)) & ConversionDone);       // Wait for conversion to complete
        }
 
 
        static RGBA16 getColor16(bool restart = true) {
            while (!isDone()) {     // Wait for conversion to be done
                core::delay(1);     // Avoid spamming the I2C
            }
 
            RGBA16 color = { 0 };
 
            color.r  = bsp::I2CA::read<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::RDATA));
            color.r |= bsp::I2CA::read<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::RDATAH)) << 8;
 
            color.g  = bsp::I2CA::read<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::GDATA));
            color.g |= bsp::I2CA::read<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::GDATAH)) << 8;
 
            color.b  = bsp::I2CA::read<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::BDATA));
            color.b |= bsp::I2CA::read<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::BDATAH)) << 8;
 
            color.a  = bsp::I2CA::read<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::BDATA));
            color.a |= bsp::I2CA::read<u8>(DeviceAddress, CommandBit | enumValue(RegisterID::BDATAH)) << 8;
 
            if(restart) startConversion();
 
            return color;
        }
 
        static RGBA8 getColor8(bool restart = true) {
            RGBA16 color16 = getColor16(restart);
 
            RGBA8 color8 = {0};
            color8.r = static_cast<u8>(color16.r >> 8);
            color8.g = static_cast<u8>(color16.g >> 8);
            color8.b = static_cast<u8>(color16.b >> 8);
            color8.a = static_cast<u8>(color16.a >> 8);
 
 
            return color8;
        }
 
    private:
 
        static inline u8 s_integrationTime;
 
        enum class RegisterID : u8{
            EN          = 0x00,     
            ATIME       = 0x01,     
            WTIME       = 0x02,     
            AILTL       = 0x04,     
            AILTH       = 0x05,     
            AIHTL       = 0x06,     
            AIHTH       = 0x07,     
            PERS        = 0x0C,     
            CNFG        = 0x0D,     
            CTRL        = 0x0F,     
            ID          = 0x12,     
            STATUS      = 0x13,     
            CDATA       = 0x14,     
            CDATAH      = 0x15,     
            RDATA       = 0x16,     
            RDATAH      = 0x17,     
            GDATA       = 0x18,     
            GDATAH      = 0x19,     
            BDATA       = 0x1A,     
            BDATAH      = 0x1B,     
 
        };
 
        struct EnableRegister {
            u8 PON          : 1;    
            u8 AEN          : 1;    
            u8 Reserved     : 1;    
            u8 WEN          : 1;    
            u8 AIEN         : 1;    
            u8 Reserved2    : 3;    
        };
        static_assert (sizeof(EnableRegister) == sizeof(u8), "Enable register definition wrong");
 
        struct StatusRegister {
            u8 AVALID       : 1;    
            u8 Reserved1    : 3;    
            u8 AINT         : 1;    
            u8 Reserved2    : 3;    
        };
        static_assert (sizeof(StatusRegister) == sizeof(u8), "Status register definition wrong");
 
        constexpr static inline u8 DeviceAddress        = 0x52;     
        constexpr static inline u8 DeviceID             = 0x44;     
        constexpr static inline u8 CommandBit           = 0x80;     
        constexpr static inline u8 ConversionDone       = 0x01;     
 
 
 
    };
 
}