niklas/as7265x-rust
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

added maybe-async

Browse Source
This commit is contained in:
Niklas Kapelle
2025-12-15 18:21:56 +01:00
parent 6691c2e38c
commit df33b51d52
3 changed files with 115 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
src/lib.rs
View File

@@ -1,10 +1,18 @@
#![no_std]
#[cfg(not(feature = "async"))]
use embedded_hal::{
delay::DelayNs,
i2c::{self},
};
#[cfg(feature = "async")]
use embedded_hal_async::{
delay::DelayNs,
i2c::{self},
};
use maybe_async::maybe_async;
const AS7265X_ADDR: u8 = 0x49;
const STATUS_REG: u8 = 0x00;
const WRITE_REG: u8 = 0x01;
@@ -330,6 +338,7 @@ where
config: AS7265XConfig,
}
#[maybe_async]
impl<I, D> AS7265X<I, D>
where
I: i2c::I2c,
@@ -343,6 +352,7 @@ where
}
}
#[maybe_async]
pub async fn init(&mut self) -> Result<(), Error<I::Error>> {
self.write_config().await?;
@@ -376,63 +386,75 @@ where
Ok(())
}
#[maybe_async]
pub async fn soft_reset(&mut self) -> Result<(), Error<I::Error>> {
self.write_virtual_register(CONFIG_ADDR, SOFT_RESET).await?;
self.delay.delay_ms(100);
self.delay.delay_ms(100).await;
Ok(())
}
#[maybe_async]
async fn write_config(&mut self) -> Result<(), Error<I::Error>> {
let config_byte = self.config.to_config_byte();
self.write_virtual_register(CONFIG_ADDR, config_byte).await
}
#[maybe_async]
pub async fn set_integration_time(&mut self, time: u8) -> Result<(), Error<I::Error>> {
self.write_virtual_register(INTEGRATION_ADDR, time).await
}
#[maybe_async]
async fn set_led_config(&mut self, led: Led, config: LedConfig) -> Result<(), Error<I::Error>> {
self.select_device(led.get_device()).await?;
let config_byte = config.config_byte();
self.write_virtual_register(LED_ADDR, config_byte).await
}
#[maybe_async]
pub async fn get_device_type(&mut self) -> Result<u8, Error<I::Error>> {
self.read_virtual_register(HW_VERSION_HIGH_ADDR).await
}
#[maybe_async]
pub async fn get_hardware_version(&mut self) -> Result<u8, Error<I::Error>> {
self.read_virtual_register(HW_VERSION_LOW_ADDR).await
}
#[maybe_async]
pub async fn get_firmware_version(&mut self) -> Result<(u8, u8), Error<I::Error>> {
let high = self.read_virtual_register(FW_VERSION_HIGH_ADDR).await?;
let low = self.read_virtual_register(FW_VERSION_LOW_ADDR).await?;
Ok((high, low))
}
#[maybe_async]
async fn select_device(&mut self, device: Device) -> Result<(), Error<I::Error>> {
self.write_virtual_register(DEV_SELECT_ADDR, device as u8)
.await
}
#[maybe_async]
pub async fn read_temperature(&mut self) -> Result<i8, Error<I::Error>> {
let temp = self.read_virtual_register(TEMP_ADDR).await?;
Ok(temp as i8)
}
#[maybe_async]
pub async fn is_data_ready(&mut self) -> Result<bool, Error<I::Error>> {
let config = self.read_virtual_register(CONFIG_ADDR).await?;
Ok((config & CONFIG_DATA_RDY) != 0)
}
#[maybe_async]
pub async fn measure(&mut self) -> Result<(), Error<I::Error>> {
self.write_config().await?;
let wait_time = (self.config.integration_time as u32) * 28 / 10 * 2;
self.delay.delay_ms(wait_time);
self.delay.delay_ms(wait_time).await;
Ok(())
}
#[maybe_async]
pub async fn mesure_with_bulb(&mut self) -> Result<(), Error<I::Error>> {
self.set_led_config(
Led::White,
@@ -490,12 +512,14 @@ where
Ok(())
}
#[maybe_async]
pub async fn read_raw_measurement(&mut self, channel: Channel) -> Result<u16, Error<I::Error>> {
let dev = channel.get_device_for_channel();
self.select_device(dev).await?;
self.read_raw_channel(channel.get_raw_address()).await
}
#[maybe_async]
pub async fn read_calibrated_messurement(
&mut self,
channel: Channel,
@@ -507,6 +531,7 @@ where
.await
}
#[maybe_async]
async fn write_virtual_register(
&mut self,
virtual_addr: u8,
@@ -517,64 +542,73 @@ where
for _ in 0..MAX_RETRIES {
let mut status = [0u8; 1];
self.device
.write_read(AS7265X_ADDR, &[STATUS_REG], &mut status)?;
.write_read(AS7265X_ADDR, &[STATUS_REG], &mut status)
.await?;
if (status[0] & TX_VALID) == 0 {
break;
}
self.delay.delay_ms(5);
self.delay.delay_ms(5).await;
}
self.device
.write(AS7265X_ADDR, &[WRITE_REG, 0x80 | virtual_addr])?;
.write(AS7265X_ADDR, &[WRITE_REG, 0x80 | virtual_addr])
.await?;
for _ in 0..MAX_RETRIES {
let mut status = [0u8; 1];
self.device
.write_read(AS7265X_ADDR, &[STATUS_REG], &mut status)?;
.write_read(AS7265X_ADDR, &[STATUS_REG], &mut status)
.await?;
if (status[0] & TX_VALID) == 0 {
break;
}
self.delay.delay_ms(5);
self.delay.delay_ms(5).await;
}
self.device.write(AS7265X_ADDR, &[WRITE_REG, data])?;
self.device.write(AS7265X_ADDR, &[WRITE_REG, data]).await?;
Ok(())
}
#[maybe_async]
async fn read_virtual_register(&mut self, virtual_addr: u8) -> Result<u8, Error<I::Error>> {
const MAX_RETRIES: u8 = 100;
for _ in 0..MAX_RETRIES {
let mut status = [0u8; 1];
self.device
.write_read(AS7265X_ADDR, &[STATUS_REG], &mut status)?;
.write_read(AS7265X_ADDR, &[STATUS_REG], &mut status)
.await?;
if (status[0] & TX_VALID) == 0 {
break;
}
self.delay.delay_ms(5);
self.delay.delay_ms(5).await;
}
self.device
.write(AS7265X_ADDR, &[WRITE_REG, virtual_addr])?;
.write(AS7265X_ADDR, &[WRITE_REG, virtual_addr])
.await?;
for _ in 0..MAX_RETRIES {
let mut status = [0u8; 1];
self.device
.write_read(AS7265X_ADDR, &[STATUS_REG], &mut status)?;
.write_read(AS7265X_ADDR, &[STATUS_REG], &mut status)
.await?;
if (status[0] & RX_VALID) != 0 {
break;
}
self.delay.delay_ms(5);
self.delay.delay_ms(5).await;
}
let mut data = [0u8; 1];
self.device
.write_read(AS7265X_ADDR, &[READ_REG], &mut data)?;
.write_read(AS7265X_ADDR, &[READ_REG], &mut data)
.await?;
Ok(data[0])
}
#[maybe_async]
async fn read_raw_channel(&mut self, high_byte_addr: u8) -> Result<u16, Error<I::Error>> {
let high = self.read_virtual_register(high_byte_addr).await?;
let low = self.read_virtual_register(high_byte_addr + 1).await?;
@@ -582,6 +616,7 @@ where
Ok(((high as u16) << 8) | (low as u16))
}
#[maybe_async]
async fn read_calibrated_channel(
&mut self,
high_byte_addr: u8,