use crate::{
BitFlags, Error, Register, RgbCGain, RgbCInterruptPersistence, Tcs3400, DEVICE_ADDRESS,
};
use embedded_hal::blocking::i2c;
impl<I2C, E> Tcs3400<I2C>
where
I2C: i2c::Write<Error = E>,
{
pub fn enable(&mut self) -> Result<(), Error<E>> {
let enable = self.enable;
self.write_enable(enable | BitFlags::POWER_ON)
}
pub fn disable(&mut self) -> Result<(), Error<E>> {
let enable = self.enable;
self.write_enable(enable & !BitFlags::POWER_ON)
}
pub fn enable_rgbc(&mut self) -> Result<(), Error<E>> {
let enable = self.enable;
self.write_enable(enable | BitFlags::RGBC_EN)
}
pub fn disable_rgbc(&mut self) -> Result<(), Error<E>> {
let enable = self.enable;
self.write_enable(enable & !BitFlags::RGBC_EN)
}
pub fn enable_rgbc_interrupts(&mut self) -> Result<(), Error<E>> {
let enable = self.enable;
self.write_enable(enable | BitFlags::RGBC_INT_EN)
}
pub fn disable_rgbc_interrupts(&mut self) -> Result<(), Error<E>> {
let enable = self.enable;
self.write_enable(enable & !BitFlags::RGBC_INT_EN)
}
pub fn enable_wait(&mut self) -> Result<(), Error<E>> {
let enable = self.enable;
self.write_enable(enable | BitFlags::WAIT_EN)
}
pub fn disable_wait(&mut self) -> Result<(), Error<E>> {
let enable = self.enable;
self.write_enable(enable & !BitFlags::WAIT_EN)
}
fn write_enable(&mut self, enable: u8) -> Result<(), Error<E>> {
self.write_register(Register::ENABLE, enable)?;
self.enable = enable;
Ok(())
}
pub fn set_wait_cycles(&mut self, cycles: u16) -> Result<(), Error<E>> {
if cycles > 256 || cycles == 0 {
return Err(Error::InvalidInputData);
}
self.write_register(Register::WTIME, (256 - cycles as u16) as u8)
}
pub fn enable_wait_long(&mut self) -> Result<(), Error<E>> {
self.write_register(Register::CONFIG, BitFlags::WLONG)
}
pub fn disable_wait_long(&mut self) -> Result<(), Error<E>> {
self.write_register(Register::CONFIG, 0)
}
pub fn set_rgbc_gain(&mut self, gain: RgbCGain) -> Result<(), Error<E>> {
match gain {
RgbCGain::_1x => self.write_register(Register::CONTROL, 0),
RgbCGain::_4x => self.write_register(Register::CONTROL, 1),
RgbCGain::_16x => self.write_register(Register::CONTROL, 2),
RgbCGain::_60x => self.write_register(Register::CONTROL, 3),
}
}
pub fn set_integration_cycles(&mut self, cycles: u16) -> Result<(), Error<E>> {
if cycles > 256 || cycles == 0 {
return Err(Error::InvalidInputData);
}
self.write_register(Register::ATIME, (256 - cycles as u16) as u8)
}
pub fn set_rgbc_interrupt_low_threshold(&mut self, threshold: u16) -> Result<(), Error<E>> {
self.write_register(Register::AILTL, threshold as u8)?;
self.write_register(Register::AILTH, (threshold >> 8) as u8)
}
pub fn set_rgbc_interrupt_high_threshold(&mut self, threshold: u16) -> Result<(), Error<E>> {
self.write_register(Register::AIHTL, threshold as u8)?;
self.write_register(Register::AIHTH, (threshold >> 8) as u8)
}
pub fn set_rgbc_interrupt_persistence(
&mut self,
persistence: RgbCInterruptPersistence,
) -> Result<(), Error<E>> {
use crate::RgbCInterruptPersistence as IP;
match persistence {
IP::Every => self.write_register(Register::APERS, 0),
IP::Any => self.write_register(Register::APERS, 1),
IP::_2 => self.write_register(Register::APERS, 2),
IP::_3 => self.write_register(Register::APERS, 3),
IP::_5 => self.write_register(Register::APERS, 4),
IP::_10 => self.write_register(Register::APERS, 5),
IP::_15 => self.write_register(Register::APERS, 6),
IP::_20 => self.write_register(Register::APERS, 7),
IP::_25 => self.write_register(Register::APERS, 8),
IP::_30 => self.write_register(Register::APERS, 9),
IP::_35 => self.write_register(Register::APERS, 10),
IP::_40 => self.write_register(Register::APERS, 11),
IP::_45 => self.write_register(Register::APERS, 12),
IP::_50 => self.write_register(Register::APERS, 13),
IP::_55 => self.write_register(Register::APERS, 14),
IP::_60 => self.write_register(Register::APERS, 15),
}
}
fn write_register(&mut self, register: u8, value: u8) -> Result<(), Error<E>> {
self.i2c
.write(DEVICE_ADDRESS, &[register, value])
.map_err(Error::I2C)
}
}