#![deny(missing_docs)]
#![deny(warnings)]
#![no_std]
#![forbid(unsafe_code)]
#![cfg_attr(docsrs, feature(doc_cfg))]
#[cfg(feature = "async")]
#[cfg_attr(docsrs, doc(cfg(feature = "async")))]
pub mod asynch;
mod touch;
pub use cst820_registers as registers;
pub use cst820_registers::{CST820_CHIP_ID, DEFAULT_DEVICE_ADDRESS, Gesture, TouchEvent};
pub use touch::Touch;
use cst820_registers::prelude::*;
use cst820_registers::{
AutoSleepTime, ChipId, DisAutoSleep, FwVersion, IrqCtl, MotionMask, ProjId, SleepMode,
};
use embedded_hal::delay::DelayNs;
use embedded_hal::digital::OutputPin;
use embedded_hal::i2c::I2c;
pub const RESET_PULSE_US: u32 = 1_000;
pub const BOOT_DELAY_MS: u32 = 100;
pub fn reset<P, D>(rst: &mut P, delay: &mut D) -> Result<(), P::Error>
where
P: OutputPin,
D: DelayNs,
{
rst.set_low()?;
delay.delay_us(RESET_PULSE_US);
rst.set_high()?;
delay.delay_ms(BOOT_DELAY_MS);
Ok(())
}
#[derive(Debug)]
pub struct Cst820<I2C> {
i2c: I2C,
address: u8,
}
impl<I2C> Cst820<I2C>
where
I2C: I2c,
{
pub fn new(i2c: I2C) -> Self {
Self::with_address(i2c, DEFAULT_DEVICE_ADDRESS)
}
pub fn with_address(i2c: I2C, address: u8) -> Self {
Self { i2c, address }
}
pub fn release(self) -> I2C {
self.i2c
}
pub fn chip_id(&mut self) -> Result<u8, I2C::Error> {
Ok(self.read_register::<ChipId>()?.value())
}
pub fn identify(&mut self) -> Result<bool, I2C::Error> {
Ok(self.chip_id()? == CST820_CHIP_ID)
}
pub fn project_id(&mut self) -> Result<u8, I2C::Error> {
Ok(self.read_register::<ProjId>()?.value())
}
pub fn firmware_version(&mut self) -> Result<u8, I2C::Error> {
Ok(self.read_register::<FwVersion>()?.value())
}
pub fn configure_gestures(&mut self, mask: MotionMask) -> Result<(), I2C::Error> {
self.write_register(mask)
}
pub fn read_touch(&mut self) -> Result<Touch, I2C::Error> {
let mut buffer = [0; Touch::LEN];
self.i2c
.write_read(self.address, &[Touch::START.addr()], &mut buffer)?;
Ok(Touch::from_bytes(&buffer))
}
pub fn configure_interrupts(&mut self, irq: IrqCtl) -> Result<(), I2C::Error> {
self.write_register(irq)
}
pub fn set_auto_sleep(&mut self, seconds: Option<u8>) -> Result<(), I2C::Error> {
match seconds {
Some(seconds) => {
self.write_register(AutoSleepTime::new().with_value(seconds))?;
self.write_register(DisAutoSleep::new())
}
None => self.write_register(DisAutoSleep::new().with_value(1)),
}
}
pub fn sleep(&mut self) -> Result<(), I2C::Error> {
self.write_register(SleepMode::deep_sleep())
}
pub fn read_register<R>(&mut self) -> Result<R, I2C::Error>
where
R: Register,
{
let mut buffer = [0];
self.i2c
.write_read(self.address, &[*R::REGISTER_ADDRESS], &mut buffer)?;
Ok(R::from_bits(buffer[0]))
}
pub fn write_register<R>(&mut self, register: R) -> Result<(), I2C::Error>
where
R: WritableRegister,
{
self.i2c
.write(self.address, &[*R::REGISTER_ADDRESS, register.to_bits()])
}
pub fn modify_register<R, F>(&mut self, f: F) -> Result<(), I2C::Error>
where
R: WritableRegister,
F: FnOnce(R) -> R,
{
let register = self.read_register::<R>()?;
self.write_register(f(register))
}
}