diff --git a/Cargo.lock b/Cargo.lock index c7dfcf2..5ff1571 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3,10 +3,12 @@ version = 4 [[package]] -name = "as7265x-rust" +name = "as7265x" version = "0.1.0" dependencies = [ "embedded-hal", + "embedded-hal-async", + "maybe-async", ] [[package]] @@ -14,3 +16,58 @@ name = "embedded-hal" version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" 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" diff --git a/Cargo.toml b/Cargo.toml index b00bd74..1c63605 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,14 @@ [package] -name = "as7265x-rust" +name = "as7265x" version = "0.1.0" edition = "2024" [dependencies] 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" ] + diff --git a/src/lib.rs b/src/lib.rs index b0e10c8..9fee0be 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -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 AS7265X where I: i2c::I2c, @@ -343,6 +352,7 @@ where } } + #[maybe_async] pub async fn init(&mut self) -> Result<(), Error> { self.write_config().await?; @@ -376,63 +386,75 @@ where Ok(()) } + #[maybe_async] pub async fn soft_reset(&mut self) -> Result<(), 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> { 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> { self.write_virtual_register(INTEGRATION_ADDR, time).await } + #[maybe_async] async fn set_led_config(&mut self, led: Led, config: LedConfig) -> Result<(), 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> { self.read_virtual_register(HW_VERSION_HIGH_ADDR).await } + #[maybe_async] pub async fn get_hardware_version(&mut self) -> Result> { self.read_virtual_register(HW_VERSION_LOW_ADDR).await } + #[maybe_async] pub async fn get_firmware_version(&mut self) -> Result<(u8, u8), 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> { self.write_virtual_register(DEV_SELECT_ADDR, device as u8) .await } + #[maybe_async] pub async fn read_temperature(&mut self) -> Result> { let temp = self.read_virtual_register(TEMP_ADDR).await?; Ok(temp as i8) } + #[maybe_async] pub async fn is_data_ready(&mut self) -> Result> { 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> { 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> { 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> { 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> { 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> { 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,