Struct EmberMug

pub struct EmberMug { /* private fields */ }

An Ember Mug device

Create an instance with EmberMug::find_and_connect or EmberMug::connect_mug

Implementations

impl EmberMug

pub async fn get_battery(&self) -> Result<Battery, ReadError>

Retrieves the battery percentage of the mug and other values.

Examples found in repository

examples/example.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mug = EmberMug::find_and_connect().await?;
    let name = mug.get_name().await?;
    println!("Connected to an Ember Mug with the name '{name}'");

    let battery = mug.get_battery().await?;
    println!("Battery level: {}%", battery.battery);

    let current_temp = mug.get_current_temperature().await?;
    let target_temp = mug.get_target_temperature().await?;
    let unit = mug.get_temperature_unit().await?;
    println!("Current temperature: {current_temp}{unit}");
    println!("Target temperature: {target_temp}{unit}");

    mug.set_target_temperature(&Temperature::from_degree(60.0))
        .await?;

    let target_temp = mug.get_target_temperature().await?;
    println!("Changed target temperature to {target_temp}{unit}");

    Ok(())
}

examples/info.rs (line 29)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

impl EmberMug

pub async fn get_current_temperature(&self) -> Result<Temperature, ReadError>

Retrieves the current temperature of the mug

Examples found in repository

examples/example.rs (line 12)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mug = EmberMug::find_and_connect().await?;
    let name = mug.get_name().await?;
    println!("Connected to an Ember Mug with the name '{name}'");

    let battery = mug.get_battery().await?;
    println!("Battery level: {}%", battery.battery);

    let current_temp = mug.get_current_temperature().await?;
    let target_temp = mug.get_target_temperature().await?;
    let unit = mug.get_temperature_unit().await?;
    println!("Current temperature: {current_temp}{unit}");
    println!("Target temperature: {target_temp}{unit}");

    mug.set_target_temperature(&Temperature::from_degree(60.0))
        .await?;

    let target_temp = mug.get_target_temperature().await?;
    println!("Changed target temperature to {target_temp}{unit}");

    Ok(())
}

examples/info.rs (line 30)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

impl EmberMug

pub async fn get_dsk(&self) -> Result<Vec<u8>, ReadError>

Retrieves the dsk of the cup

Examples found in repository

examples/info.rs (line 41)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

pub async fn get_udsk(&self) -> Result<Vec<u8>, ReadError>

Retrieves the dsk of the cup

Examples found in repository

examples/info.rs (line 42)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

impl EmberMug

pub async fn get_liquid_level(&self) -> Result<LiquidLevel, ReadError>

Retrieves the level of liquid present in the cup

impl EmberMug

pub async fn get_liquid_state(&self) -> Result<LiquidState, ReadError>

The current state of the mug

Examples found in repository

examples/info.rs (line 33)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

impl EmberMug

pub async fn get_mug_color(&self) -> Result<Color, ReadError>

Retrieves the color of the mug’s LED indicator.

Examples found in repository

examples/info.rs (line 31)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

pub async fn set_mug_color(&self, color: &Color) -> Result<(), WriteError>

Sets the color of the mug’s LED indicator.

impl EmberMug

pub async fn get_mug_meta(&self) -> Result<MugMeta, ReadError>

Retrieves id of the mug

Examples found in repository

examples/info.rs (line 40)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

impl EmberMug

pub async fn get_name(&self) -> Result<String, ReadError>

Retreives the name of the mug.

Examples found in repository

examples/example.rs (line 6)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mug = EmberMug::find_and_connect().await?;
    let name = mug.get_name().await?;
    println!("Connected to an Ember Mug with the name '{name}'");

    let battery = mug.get_battery().await?;
    println!("Battery level: {}%", battery.battery);

    let current_temp = mug.get_current_temperature().await?;
    let target_temp = mug.get_target_temperature().await?;
    let unit = mug.get_temperature_unit().await?;
    println!("Current temperature: {current_temp}{unit}");
    println!("Target temperature: {target_temp}{unit}");

    mug.set_target_temperature(&Temperature::from_degree(60.0))
        .await?;

    let target_temp = mug.get_target_temperature().await?;
    println!("Changed target temperature to {target_temp}{unit}");

    Ok(())
}

examples/info.rs (line 32)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

pub async fn set_name(&self, name: &str) -> Result<(), WriteError>

Sets the name of the mug.

impl EmberMug

pub async fn get_ota(&self) -> Result<Ota, ReadError>

Info about the current firmware running on the mug.

Examples found in repository

examples/info.rs (line 38)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

impl EmberMug

pub async fn get_push_event(&self) -> Result<PushEvent, ReadError>

Events sent by the mug for the application to register to.

Call subscribe_push_events first, and prefer to use listen_push_events instead

pub async fn subscribe_push_events(&self) -> Result<(), ReadError>

Subscribe to events sent by the mug

pub async fn listen_push_events( &self, ) -> Result<impl Stream<Item = Result<PushEvent, ReadError>> + Send + '_, ReadError>

Get a stream of events sent by the mug. You need to use subscribe_push_events to get events. The stream is not valid across connections.

pub async fn unsubscribe_push_events(&self) -> Result<(), ReadError>

Unsubscribe to events sent by the mug

impl EmberMug

pub async fn get_target_temperature(&self) -> Result<Temperature, ReadError>

Retrieves the target temperature of the mug

Examples found in repository

examples/example.rs (line 13)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mug = EmberMug::find_and_connect().await?;
    let name = mug.get_name().await?;
    println!("Connected to an Ember Mug with the name '{name}'");

    let battery = mug.get_battery().await?;
    println!("Battery level: {}%", battery.battery);

    let current_temp = mug.get_current_temperature().await?;
    let target_temp = mug.get_target_temperature().await?;
    let unit = mug.get_temperature_unit().await?;
    println!("Current temperature: {current_temp}{unit}");
    println!("Target temperature: {target_temp}{unit}");

    mug.set_target_temperature(&Temperature::from_degree(60.0))
        .await?;

    let target_temp = mug.get_target_temperature().await?;
    println!("Changed target temperature to {target_temp}{unit}");

    Ok(())
}

examples/info.rs (line 36)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

pub async fn set_target_temperature( &self, temperature: &Temperature, ) -> Result<(), WriteError>

Set the target temperature of the mug

Examples found in repository

examples/example.rs (line 18)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mug = EmberMug::find_and_connect().await?;
    let name = mug.get_name().await?;
    println!("Connected to an Ember Mug with the name '{name}'");

    let battery = mug.get_battery().await?;
    println!("Battery level: {}%", battery.battery);

    let current_temp = mug.get_current_temperature().await?;
    let target_temp = mug.get_target_temperature().await?;
    let unit = mug.get_temperature_unit().await?;
    println!("Current temperature: {current_temp}{unit}");
    println!("Target temperature: {target_temp}{unit}");

    mug.set_target_temperature(&Temperature::from_degree(60.0))
        .await?;

    let target_temp = mug.get_target_temperature().await?;
    println!("Changed target temperature to {target_temp}{unit}");

    Ok(())
}

impl EmberMug

pub async fn get_temperature_unit(&self) -> Result<TemperatureUnit, ReadError>

Retrieve the current unit of temperature used by the mug.

Examples found in repository

examples/example.rs (line 14)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mug = EmberMug::find_and_connect().await?;
    let name = mug.get_name().await?;
    println!("Connected to an Ember Mug with the name '{name}'");

    let battery = mug.get_battery().await?;
    println!("Battery level: {}%", battery.battery);

    let current_temp = mug.get_current_temperature().await?;
    let target_temp = mug.get_target_temperature().await?;
    let unit = mug.get_temperature_unit().await?;
    println!("Current temperature: {current_temp}{unit}");
    println!("Target temperature: {target_temp}{unit}");

    mug.set_target_temperature(&Temperature::from_degree(60.0))
        .await?;

    let target_temp = mug.get_target_temperature().await?;
    println!("Changed target temperature to {target_temp}{unit}");

    Ok(())
}

pub async fn set_temperature_unit( &self, temperature_unit: &TemperatureUnit, ) -> Result<(), WriteError>

Set the current unit of temperature used by the mug.

impl EmberMug

pub async fn get_time_date_zone(&self) -> Result<TimeDateZone, ReadError>

Get the current date and timezone on the mug

Examples found in repository

examples/info.rs (line 39)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

pub async fn set_time_date_zone( &self, time_date_zone: &TimeDateZone, ) -> Result<(), WriteError>

A sink for the mug to store the current date and timezone

impl EmberMug

pub async fn find_and_connect() -> Result<Self, ConnectError>

Find and connect to the first available Ember Mug

Examples found in repository

examples/example.rs (line 5)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mug = EmberMug::find_and_connect().await?;
    let name = mug.get_name().await?;
    println!("Connected to an Ember Mug with the name '{name}'");

    let battery = mug.get_battery().await?;
    println!("Battery level: {}%", battery.battery);

    let current_temp = mug.get_current_temperature().await?;
    let target_temp = mug.get_target_temperature().await?;
    let unit = mug.get_temperature_unit().await?;
    println!("Current temperature: {current_temp}{unit}");
    println!("Target temperature: {target_temp}{unit}");

    mug.set_target_temperature(&Temperature::from_degree(60.0))
        .await?;

    let target_temp = mug.get_target_temperature().await?;
    println!("Changed target temperature to {target_temp}{unit}");

    Ok(())
}

examples/info.rs (line 15)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

pub async fn connect_mug( adapter: Adapter, peripheral: <Adapter as Central>::Peripheral, ) -> Result<Self, ConnectError>

Connect to specific Ember Mug

pub async fn is_connected(&self) -> Result<bool, Error>

Returns true if the device is connected, the device might be considered disconnected if it doesn’t respond in 1 second

pub async fn disconnected(&self) -> Result<(), Error>

Returns when the device is disconnected.

impl EmberMug

pub fn get_characteristic(&self, uuid: &Uuid) -> Option<&Characteristic>

Get characteristic on EMBER_MUG_SERVICE_UUID with given UUID

pub fn get_characteristics(&self) -> impl Iterator<Item = &Characteristic>

Get all characteristics

Examples found in repository

examples/info.rs (line 16)

async fn run() -> Result<(), color_eyre::Report> {
    for _ in 0..2 {
        let mug = ember_mug::EmberMug::find_and_connect().await?;
        let mut chars: Vec<_> = mug.get_characteristics().collect();
        let known = ember_mug::KnownCharacteristic::all();
        for k in known {
            let Some(char) = chars.iter().position(|&c| c.uuid == k.get()) else {
                println!("couldn't find {k:?}");
                continue;
            };
            let char = chars.remove(char);
            println!("known: {k:?}\n{} cap: {:?}", char.uuid, char.properties);
        }
        for ch in chars {
            tracing::info!(?ch, "was left");
        }
        println!("battery: {:?}", mug.get_battery().await?);
        println!("current_temp: {}", mug.get_current_temperature().await?);
        println!("color: {:?}", mug.get_mug_color().await?);
        println!("name: {:?}", mug.get_name().await?);
        println!("state: {:?}", mug.get_liquid_state().await?);
        println!(
            "target_temperature: {}",
            mug.get_target_temperature().await?
        );
        println!("ota: {:?}", mug.get_ota().await?);
        println!("tdz: {:?}", mug.get_time_date_zone().await?);
        println!("meta: {:?}", mug.get_mug_meta().await?);
        println!("dsk: {:?}", mug.get_dsk().await?);
        println!("udsk: {:?}", mug.get_udsk().await?);
    }
    Ok(())
}

pub fn get_characteristic_on_service( &self, uuid: &Uuid, service_uuid: &Uuid, ) -> Option<&Characteristic>

Get characteristic on given service UUID with given UUID

impl EmberMug

pub async fn read_deserialize<T: BinRead + ReadEndian>( &self, uuid: &KnownCharacteristic, ) -> Result<T, ReadError>

where for<'a> T::Args<'a>: Default,

Read data from given characteristic with uuid

pub async fn read( &self, uuid: &KnownCharacteristic, ) -> Result<Vec<u8>, ReadError>

Deserialize data on given characteristic with uuid

pub async fn write<D>( &self, write: WriteType, uuid: &KnownCharacteristic, data: &D, ) -> Result<(), WriteError>

where D: BinWrite + WriteEndian + Send + Sync, for<'a> <D as BinWrite>::Args<'a>: Default,

Write data to given characteristic on uuid

pub async fn command<D>( &self, uuid: &KnownCharacteristic, data: &D, ) -> Result<(), WriteError>

where D: BinWrite + WriteEndian + Send + Sync, for<'a> <D as BinWrite>::Args<'a>: Default,

Send command to given characteristic on uuid

pub async fn request<D>( &self, uuid: &KnownCharacteristic, data: &D, ) -> Result<(), WriteError>

where D: BinWrite + WriteEndian + Send + Sync, for<'a> <D as BinWrite>::Args<'a>: Default,

Send request to given characteristic on uuid

Trait Implementations

impl Clone for EmberMug

fn clone(&self) -> EmberMug

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.