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

59
Cargo.lock generated
View File

@@ -3,10 +3,12 @@
version = 4 version = 4
[[package]] [[package]]
name = "as7265x-rust" name = "as7265x"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"embedded-hal", "embedded-hal",
"embedded-hal-async",
"maybe-async",
] ]
[[package]] [[package]]
@@ -14,3 +16,58 @@ name = "embedded-hal"
version = "1.0.0" version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "361a90feb7004eca4019fb28352a9465666b24f840f5c3cddf0ff13920590b89" checksum = "361a90feb7004eca4019fb28352a9465666b24f840f5c3cddf0ff13920590b89"
[[package]]
name = "embedded-hal-async"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c4c685bbef7fe13c3c6dd4da26841ed3980ef33e841cddfa15ce8a8fb3f1884"
dependencies = [
"embedded-hal",
]
[[package]]
name = "maybe-async"
version = "0.2.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5cf92c10c7e361d6b99666ec1c6f9805b0bea2c3bd8c78dc6fe98ac5bd78db11"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "proc-macro2"
version = "1.0.103"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.42"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
dependencies = [
"proc-macro2",
]
[[package]]
name = "syn"
version = "2.0.111"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "unicode-ident"
version = "1.0.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"

9
Cargo.toml
View File

@@ -1,7 +1,14 @@
[package] [package]
name = "as7265x-rust" name = "as7265x"
version = "0.1.0" version = "0.1.0"
edition = "2024" edition = "2024"
[dependencies] [dependencies]
embedded-hal = "1.0.0" embedded-hal = "1.0.0"
maybe-async = { version = "0.2.10", features=["is_sync"]}
embedded-hal-async = { version = "1.0.0", optional = true }
[features]
async = [ "embedded-hal-async" ]

63
src/lib.rs
View File

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