somose 0.2.0

#![no_std]

use embedded_hal::i2c::I2c;

// I2C command constants
const CMD_HUMIDITY: u8 = 0x76;
const CMD_TEMPERATURE: u8 = 0x74;
const CMD_RAW_HUMIDITY: u8 = 0x72;
const CMD_REFERENCE_DRY: u8 = 0x64;
const CMD_REFERENCE_WET: u8 = 0x75;
const CMD_HARDWARE_VERSION: u8 = 0x68;
const CMD_FIRMWARE_VERSION: u8 = 0x66;
const CMD_SET_REFERENCE_DRY: u8 = 0x44;
const CMD_SET_REFERENCE_WET: u8 = 0x55;
const CMD_SET_NEW_ADDR: u8 = 0x41;
const CMD_RESET: u8 = 0x52;
const CMD_FACTORY_RESET: u8 = 0x46;
const CMD_SET_ENERGY_SAVE: u8 = 0x4C;
const CMD_START_MEASUREMENT: u8 = 0x4D;
const CMD_OPTIONS: u8 = 0x6F;

/// Driver for the BeFlE i2c soil moisture sensor
///
/// This driver provides both synchronous and asynchronous interfaces
/// for communicating with the Somose soil moisture sensor via I2C.
pub struct Somose<I2C> {
    i2c: I2C,
    addr: u8,
}

impl<I2C: I2c> Somose<I2C> {
    /// Create a new Somose driver instance
    ///
    /// # Arguments
    /// * `i2c` - The I2C bus instance
    /// * `addr` - The I2C address of the sensor (typically 0x55)
    ///
    /// # Returns
    /// Returns a Result containing the initialized driver or an I2C error
    pub fn new(i2c: I2C, addr: u8) -> Result<Self, I2C::Error> {
        let mut this = Self { i2c, addr };

        // Verify sensor communication by reading firmware version
        let _ = this.firmware_version()?;

        Ok(this)
    }

    /// Read humidity values from the sensor
    ///
    /// # Returns
    /// Returns a tuple containing (average_humidity, last_measurement)
    /// Both values are percentages (0-100)
    pub fn humidity(&mut self) -> Result<(u8, u8), I2C::Error> {
        let mut read = [0u8; 2];
        self.i2c.write_read(self.addr, &[CMD_HUMIDITY], &mut read)?;
        Ok((read[0], read[1]))
    }

    /// Read temperature from the sensor
    ///
    /// # Returns
    /// Returns the temperature in degrees Celsius
    pub fn temperature(&mut self) -> Result<i8, I2C::Error> {
        let mut read = [0u8; 1];
        self.i2c
            .write_read(self.addr, &[CMD_TEMPERATURE], &mut read)?;
        Ok(read[0] as i8)
    }

    /// Read raw humidity value from the sensor
    ///
    /// # Returns
    /// Returns the raw 16-bit humidity reading
    pub fn raw_humidity(&mut self) -> Result<u16, I2C::Error> {
        let mut read = [0u8; 2];
        self.i2c
            .write_read(self.addr, &[CMD_RAW_HUMIDITY], &mut read)?;
        Ok(u16::from_be_bytes(read))
    }

    /// Read the dry reference value
    ///
    /// # Returns
    /// Returns the 16-bit dry reference calibration value
    pub fn reference_dry(&mut self) -> Result<u16, I2C::Error> {
        let mut read = [0u8; 2];
        self.i2c
            .write_read(self.addr, &[CMD_REFERENCE_DRY], &mut read)?;
        Ok(u16::from_be_bytes(read))
    }

    /// Read the wet reference value
    ///
    /// # Returns
    /// Returns the 16-bit wet reference calibration value
    pub fn reference_wet(&mut self) -> Result<u16, I2C::Error> {
        let mut read = [0u8; 2];
        self.i2c
            .write_read(self.addr, &[CMD_REFERENCE_WET], &mut read)?;
        Ok(u16::from_be_bytes(read))
    }

    /// Read hardware version
    ///
    /// # Returns
    /// Returns a tuple containing (major_version, minor_version)
    pub fn hardware_version(&mut self) -> Result<(u8, u8), I2C::Error> {
        let mut read = [0u8; 4];
        self.i2c
            .write_read(self.addr, &[CMD_HARDWARE_VERSION], &mut read)?;

        debug_assert_eq!(read[0], b'v');
        debug_assert_eq!(read[2], b'.');

        Ok((read[1], read[3]))
    }

    /// Read firmware version
    ///
    /// # Returns
    /// Returns a tuple containing (major_version, minor_version)
    pub fn firmware_version(&mut self) -> Result<(u8, u8), I2C::Error> {
        let mut read = [0u8; 4];
        self.i2c
            .write_read(self.addr, &[CMD_FIRMWARE_VERSION], &mut read)?;

        debug_assert_eq!(read[0], b'v');
        debug_assert_eq!(read[2], b'.');

        Ok((read[1], read[3]))
    }

    /// Set the dry reference calibration value
    ///
    /// # Arguments
    /// * `value` - The 16-bit dry reference value
    pub fn set_reference_dry(&mut self, value: u16) -> Result<(), I2C::Error> {
        let bytes = value.to_be_bytes();
        self.i2c
            .write(self.addr, &[CMD_SET_REFERENCE_DRY, bytes[0], bytes[1]])
    }

    /// Set the wet reference calibration value
    ///
    /// # Arguments
    /// * `value` - The 16-bit wet reference value
    pub fn set_reference_wet(&mut self, value: u16) -> Result<(), I2C::Error> {
        let bytes = value.to_be_bytes();
        self.i2c
            .write(self.addr, &[CMD_SET_REFERENCE_WET, bytes[0], bytes[1]])
    }

    /// Change the I2C address of the sensor
    ///
    /// # Arguments
    /// * `addr` - The new I2C address (7-bit)
    ///
    /// # Note
    /// This change persists after power cycling
    pub fn set_new_addr(&mut self, addr: u8) -> Result<(), I2C::Error> {
        self.i2c.write(self.addr, &[CMD_SET_NEW_ADDR, addr])?;
        self.addr = addr;
        Ok(())
    }

    /// Reset the sensor
    pub fn reset(&mut self) -> Result<(), I2C::Error> {
        self.i2c.write(self.addr, &[CMD_RESET])
    }

    /// Perform a factory reset of the sensor
    ///
    /// # Note
    /// This will reset all calibration values and settings
    pub fn factory_reset(&mut self) -> Result<(), I2C::Error> {
        self.i2c.write(self.addr, &[CMD_FACTORY_RESET])
    }

    /// Enable or disable energy saving mode
    ///
    /// # Arguments
    /// * `enable` - true to enable energy saving, false to disable
    pub fn set_energy_save(&mut self, enable: bool) -> Result<(), I2C::Error> {
        self.i2c.write(
            self.addr,
            &[CMD_SET_ENERGY_SAVE, if enable { 1 } else { 0 }],
        )
    }

    /// Start a measurement cycle
    ///
    /// # Arguments
    /// * `repetitions` - Number of measurement repetitions to perform
    pub fn start_measurement(&mut self, repetitions: u8) -> Result<(), I2C::Error> {
        self.i2c
            .write(self.addr, &[CMD_START_MEASUREMENT, repetitions])
    }

    /// Read current sensor options/status
    ///
    /// # Returns
    /// Returns an Options struct containing current sensor state
    pub fn options(&mut self) -> Result<Options, I2C::Error> {
        let mut read = [0u8; 1];
        self.i2c.write_read(self.addr, &[CMD_OPTIONS], &mut read)?;

        Ok(Options {
            measurement_active: read[0] & 1 != 0,
            energy_save_active: (read[0] & (1 << 1)) != 0,
        })
    }
}

impl<I2C: embedded_hal_async::i2c::I2c> Somose<I2C> {
    /// Create a new Somose driver instance (async version)
    ///
    /// # Arguments
    /// * `i2c` - The async I2C bus instance
    /// * `addr` - The I2C address of the sensor (typically 0x55)
    ///
    /// # Returns
    /// Returns a Result containing the initialized driver or an I2C error
    pub async fn new_async(i2c: I2C, addr: u8) -> Result<Self, I2C::Error> {
        let mut this = Self { i2c, addr };

        // Verify sensor communication by reading firmware version
        let _ = this.firmware_version_async().await?;

        Ok(this)
    }

    /// Read humidity values from the sensor (async version)
    ///
    /// # Returns
    /// Returns a tuple containing (average_humidity, last_measurement)
    /// Both values are percentages (0-100)
    pub async fn humidity_async(&mut self) -> Result<(u8, u8), I2C::Error> {
        let mut read = [0u8; 2];
        self.i2c
            .write_read(self.addr, &[CMD_HUMIDITY], &mut read)
            .await?;
        Ok((read[0], read[1]))
    }

    /// Read temperature from the sensor (async version)
    ///
    /// # Returns
    /// Returns the temperature in degrees Celsius
    pub async fn temperature_async(&mut self) -> Result<i8, I2C::Error> {
        let mut read = [0u8; 1];
        self.i2c
            .write_read(self.addr, &[CMD_TEMPERATURE], &mut read)
            .await?;
        Ok(read[0] as i8)
    }

    /// Read raw humidity value from the sensor (async version)
    ///
    /// # Returns
    /// Returns the raw 16-bit humidity reading
    pub async fn raw_humidity_async(&mut self) -> Result<u16, I2C::Error> {
        let mut read = [0u8; 2];
        self.i2c
            .write_read(self.addr, &[CMD_RAW_HUMIDITY], &mut read)
            .await?;
        Ok(u16::from_be_bytes(read))
    }

    /// Read the dry reference value (async version)
    ///
    /// # Returns
    /// Returns the 16-bit dry reference calibration value
    pub async fn reference_dry_async(&mut self) -> Result<u16, I2C::Error> {
        let mut read = [0u8; 2];
        self.i2c
            .write_read(self.addr, &[CMD_REFERENCE_DRY], &mut read)
            .await?;
        Ok(u16::from_be_bytes(read))
    }

    /// Read the wet reference value (async version)
    ///
    /// # Returns
    /// Returns the 16-bit wet reference calibration value
    pub async fn reference_wet_async(&mut self) -> Result<u16, I2C::Error> {
        let mut read = [0u8; 2];
        self.i2c
            .write_read(self.addr, &[CMD_REFERENCE_WET], &mut read)
            .await?;
        Ok(u16::from_be_bytes(read))
    }

    /// Read hardware version (async version)
    ///
    /// # Returns
    /// Returns a tuple containing (major_version, minor_version)
    pub async fn hardware_version_async(&mut self) -> Result<(u8, u8), I2C::Error> {
        let mut read = [0u8; 4];
        self.i2c
            .write_read(self.addr, &[CMD_HARDWARE_VERSION], &mut read)
            .await?;

        debug_assert_eq!(read[0], b'v');
        debug_assert_eq!(read[2], b'.');

        Ok((read[1], read[3]))
    }

    /// Read firmware version (async version)
    ///
    /// # Returns
    /// Returns a tuple containing (major_version, minor_version)
    pub async fn firmware_version_async(&mut self) -> Result<(u8, u8), I2C::Error> {
        let mut read = [0u8; 4];
        self.i2c
            .write_read(self.addr, &[CMD_FIRMWARE_VERSION], &mut read)
            .await?;

        debug_assert_eq!(read[0], b'v');
        debug_assert_eq!(read[2], b'.');

        Ok((read[1], read[3]))
    }

    /// Set the dry reference calibration value (async version)
    ///
    /// # Arguments
    /// * `value` - The 16-bit dry reference value
    pub async fn set_reference_dry_async(&mut self, value: u16) -> Result<(), I2C::Error> {
        let bytes = value.to_be_bytes();
        self.i2c
            .write(self.addr, &[CMD_SET_REFERENCE_DRY, bytes[0], bytes[1]])
            .await
    }

    /// Set the wet reference calibration value (async version)
    ///
    /// # Arguments
    /// * `value` - The 16-bit wet reference value
    pub async fn set_reference_wet_async(&mut self, value: u16) -> Result<(), I2C::Error> {
        let bytes = value.to_be_bytes();
        self.i2c
            .write(self.addr, &[CMD_SET_REFERENCE_WET, bytes[0], bytes[1]])
            .await
    }

    /// Change the I2C address of the sensor (async version)
    ///
    /// # Arguments
    /// * `addr` - The new I2C address (7-bit)
    ///
    /// # Note
    /// This change persists after power cycling
    pub async fn set_new_addr_async(&mut self, addr: u8) -> Result<(), I2C::Error> {
        self.i2c.write(self.addr, &[CMD_SET_NEW_ADDR, addr]).await?;
        self.addr = addr;
        Ok(())
    }

    /// Reset the sensor (async version)
    pub async fn reset_async(&mut self) -> Result<(), I2C::Error> {
        self.i2c.write(self.addr, &[CMD_RESET]).await
    }

    /// Perform a factory reset of the sensor (async version)
    ///
    /// # Note
    /// This will reset all calibration values and settings
    pub async fn factory_reset_async(&mut self) -> Result<(), I2C::Error> {
        self.i2c.write(self.addr, &[CMD_FACTORY_RESET]).await
    }

    /// Enable or disable energy saving mode (async version)
    ///
    /// # Arguments
    /// * `enable` - true to enable energy saving, false to disable
    pub async fn set_energy_save_async(&mut self, enable: bool) -> Result<(), I2C::Error> {
        self.i2c
            .write(
                self.addr,
                &[CMD_SET_ENERGY_SAVE, if enable { 1 } else { 0 }],
            )
            .await
    }

    /// Start a measurement cycle (async version)
    ///
    /// # Arguments
    /// * `repetitions` - Number of measurement repetitions to perform
    pub async fn start_measurement_async(&mut self, repetitions: u8) -> Result<(), I2C::Error> {
        self.i2c
            .write(self.addr, &[CMD_START_MEASUREMENT, repetitions])
            .await
    }

    /// Read current sensor options/status (async version)
    ///
    /// # Returns
    /// Returns an Options struct containing current sensor state
    pub async fn options_async(&mut self) -> Result<Options, I2C::Error> {
        let mut read = [0u8; 1];
        self.i2c
            .write_read(self.addr, &[CMD_OPTIONS], &mut read)
            .await?;

        Ok(Options {
            measurement_active: read[0] & 1 != 0,
            energy_save_active: (read[0] & (1 << 1)) != 0,
        })
    }
}

/// Sensor options and status information
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Options {
    /// Whether a measurement is currently active
    pub measurement_active: bool,
    /// Whether energy saving mode is enabled
    pub energy_save_active: bool,
}