Struct Peripheral

pub struct Peripheral { /* private fields */ }

A remote peripheral device.

The Peripheral object represents remote peripheral devices that your app discovers with a central manager. Peripherals use universally unique identifiers (UUIDs) to identify themselves. Peripherals may contain one or more services or provide useful information about their connected signal strength.

You use this object to discover, explore, and interact with the services available on a remote peripheral that supports Bluetooth low energy. A service encapsulates the way part of the device behaves. For example, one service of a heart rate monitor may be to expose heart rate data from a sensor. Services themselves contain of characteristics or included services (references to other services). Characteristics provide further details about a peripheral’s service. For example, the heart rate service may contain multiple characteristics. One characteristic could describe the intended body location of the device’s heart rate sensor, and another characteristic could transmit the heart rate measurement data. Finally, characteristics contain any number of descriptors that provide more information about the characteristic’s value, such as a human-readable description and a way to format the value.

Implementations

impl Peripheral

pub fn id(&self) -> Uuid

Peripheral identifier.

pub fn discover_services(&self)

Discovers all available services of the peripheral.

See discover_services_with_uuids.

pub fn discover_services_with_uuids(&self, uuids: &[Uuid])

Discovers peripheral’s services with the specified uuids.

When the peripheral discovers one or more services, it triggers ServicesDiscovered event.

pub fn discover_included_services(&self, service: &Service)

Discovers all available included services of a previously-discovered service.

See discover_included_services_with_uuids method.

pub fn discover_included_services_with_uuids( &self, service: &Service, uuids: &[Uuid], )

Discovers the specified included services of a previously-discovered service.

When the peripheral discovers one or more included services, it triggers IncludedServicesDiscovered event.

pub fn discover_characteristics(&self, service: &Service)

Discovers all available characteristics of a service.

See discover_characteristics_with_uuids method.

pub fn discover_characteristics_with_uuids( &self, service: &Service, uuids: &[Uuid], )

Discovers the specified characteristics of a service.

When the peripheral discovers one or more characteristics, it triggers CharacteristicsDiscovered event.

pub fn discover_descriptors(&self, characteristic: &Characteristic)

Discovers the descriptors of a characteristic.

When the peripheral discovers one or more descriptors, it triggers DescriptorsDiscovered event.

pub fn subscribe(&self, characteristic: &Characteristic)

Subscribes to notifications or indications of the value of a specified characteristic.

After calling this method the peripheral triggers SubscriptionChangeResult event to inform whether the action succeeded. If successful, the peripheral then triggers CharacteristicValue event whenever the characteristic value changes.

Because the peripheral chooses when it sends an update, your app should prepare to handle them as long as subscription remains active. If the specified characteristic’s configuration allows both notifications and indications, calling this method enables notifications only. You can disable notifications and indications for a characteristic’s value by calling unsubscribe method.

pub fn unsubscribe(&self, characteristic: &Characteristic)

Cancel subscription for characteristic value created by subscribe method.

pub fn read_characteristic(&self, characteristic: &Characteristic)

Retrieves the value of a specified characteristic.

After calling this method the peripheral triggers CharacteristicValue event.

Not all characteristics have a readable value. You can determine whether a characteristic’s value is readable by accessing the relevant properties of the Properties object.

pub fn write_characteristic( &self, characteristic: &Characteristic, value: &[u8], kind: WriteKind, )

Writes the value of a characteristic.

When you call this method to write the value of a characteristic, the peripheral triggers WriteCharacteristicResult event, but only if the WithResponse write kind is requested.

If you specify the write kind as WithoutResponse, Core Bluetooth attempts to write the value but doesn’t guarantee success. If the write doesn’t succeed in this case, you aren’t notified and you don’t receive an error indicating the cause of the failure.

Examine can_write and can_write_without_response properties to determine which kinds of writes you can perform.

pub fn read_descriptor(&self, descriptor: &Descriptor)

Retrieves the value of a specified characteristic descriptor.

After calling this method the peripheral triggers DescriptorValue event.

pub fn write_descriptor(&self, descriptor: &Descriptor, value: &[u8])

Writes the value of a characteristic descriptor.

When you call this method to write the value of a characteristic, the peripheral triggers WriteDescriptorResult event.

pub fn read_rssi(&self)

Retrieves the current RSSI value for the peripheral while connected to the central manager.

After calling this method the peripheral triggers ReadRssiResult event.

pub fn get_max_write_len(&self)

Queries for maximum length of data that can be written to characteristic in a single request. The result is returned as GetMaxWriteLenResult event.

pub fn get_max_write_len_tagged(&self, tag: Tag)

Allows tagging an asynchronous get_max_write_len call with arbitrary tag.

Trait Implementations

impl Clone for Peripheral

fn clone(&self) -> Peripheral

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Peripheral

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Peripheral

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Peripheral

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Peripheral