Struct bluenrg::ActiveBlueNRG

pub struct ActiveBlueNRG<'bnrg, 'spi, 'dbuf, SPI, OutputPin1, OutputPin2, InputPin, GpioError> { /* fields omitted */ }

Handle for actively communicating with the controller over the SPI bus.

An ActiveBlueNRG should not be created by the application, but is passed to closures given to BlueNRG::with_spi. ActiveBlueNRG implements bluetooth_hci::Controller, so it is used to access the HCI functions for the controller.

Trait Implementations

impl<'bnrg, 'spi, 'dbuf, SPI, OutputPin1, OutputPin2, InputPin, SpiError, GpioError> Commands for ActiveBlueNRG<'bnrg, 'spi, 'dbuf, SPI, OutputPin1, OutputPin2, InputPin, GpioError> where
    SPI: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    OutputPin1: OutputPin<Error = GpioError>,
    OutputPin2: OutputPin<Error = GpioError>,
    InputPin: InputPin<Error = GpioError>, 

type Error = Error<SpiError, GpioError>

Type of communication errors.

fn set_nondiscoverable(&mut self) -> Result<(), Self::Error>

Set the device in non-discoverable mode. This command will disable the LL advertising and put the device in standby state.

fn set_limited_discoverable<'a, 'b>(
    &mut self,
    params: &DiscoverableParameters<'a, 'b>
) -> Result<(), Error<Self::Error>>

Set the device in limited discoverable mode.

fn set_discoverable<'a, 'b>(
    &mut self,
    params: &DiscoverableParameters<'a, 'b>
) -> Result<(), Error<Self::Error>>

Set the device in discoverable mode.

fn set_direct_connectable(
    &mut self,
    params: &DirectConnectableParameters
) -> Result<(), Error<Self::Error>>

Set the device in direct connectable mode.

fn set_io_capability(
    &mut self,
    capability: IoCapability
) -> Result<(), Self::Error>

Set the IO capabilities of the device.

fn set_authentication_requirement(
    &mut self,
    params: &AuthenticationRequirements
) -> Result<(), Error<Self::Error>>

Set the authentication requirements for the device.

fn set_authorization_requirement(
    &mut self,
    conn_handle: ConnectionHandle,
    authorization_required: bool
) -> Result<(), Self::Error>

Set the authorization requirements of the device.

fn pass_key_response(
    &mut self,
    conn_handle: ConnectionHandle,
    pin: u32
) -> Result<(), Error<Self::Error>>

This command should be send by the host in response to the GAP Pass Key Request event.

fn authorization_response(
    &mut self,
    conn_handle: ConnectionHandle,
    authorization: Authorization
) -> Result<(), Self::Error>

This command should be send by the host in response to the GAP Authorization Request event.

fn init(
    &mut self,
    role: Role,
    privacy_enabled: bool,
    dev_name_characteristic_len: u8
) -> Result<(), Self::Error>

Register the GAP service with the GATT.

fn set_nonconnectable(
    &mut self,
    advertising_type: AdvertisingType,
    address_type: AddressType
) -> Result<(), Error<Self::Error>>

Put the device into non-connectable mode.

fn set_undirected_connectable(
    &mut self,
    filter_policy: AdvertisingFilterPolicy,
    address_type: AddressType
) -> Result<(), Error<Self::Error>>

Put the device into undirected connectable mode.

fn peripheral_security_request(
    &mut self,
    params: &SecurityRequestParameters
) -> Result<(), Self::Error>

This command has to be issued to notify the central device of the security requirements of the peripheral.

fn update_advertising_data(
    &mut self,
    data: &[u8]
) -> Result<(), Error<Self::Error>>

This command can be used to update the advertising data for a particular AD type. If the AD type specified does not exist, then it is added to the advertising data. If the overall advertising data length is more than 31 octets after the update, then the command is rejected and the old data is retained.

fn delete_ad_type(
    &mut self,
    ad_type: AdvertisingDataType
) -> Result<(), Self::Error>

This command can be used to delete the specified AD type from the advertisement data if present.

fn get_security_level(&mut self) -> Result<(), Self::Error>

This command can be used to get the current security settings of the device.

fn set_event_mask(&mut self, flags: EventFlags) -> Result<(), Self::Error>

Allows masking events from the GAP.

fn configure_white_list(&mut self) -> Result<(), Self::Error>

Configure the controller's white list with devices that are present in the security database.

fn terminate(
    &mut self,
    conn_handle: ConnectionHandle,
    reason: Status<Status>
) -> Result<(), Error<Self::Error>>

Command the controller to terminate the connection.

fn clear_security_database(&mut self) -> Result<(), Self::Error>

Clear the security database. All the devices in the security database will be removed.

fn allow_rebond(
    &mut self,
    conn_handle: ConnectionHandle
) -> Result<(), Self::Error>

This command should be given by the application when it receives the GAP Bond Lost event if it wants the re-bonding to happen successfully. If this command is not given on receiving the event, the bonding procedure will timeout.

fn start_limited_discovery_procedure(
    &mut self,
    params: &DiscoveryProcedureParameters
) -> Result<(), Self::Error>

Start the limited discovery procedure.

fn start_general_discovery_procedure(
    &mut self,
    params: &DiscoveryProcedureParameters
) -> Result<(), Self::Error>

Start the general discovery procedure. The controller is commanded to start active scanning.

fn start_name_discovery_procedure(
    &mut self,
    params: &NameDiscoveryProcedureParameters
) -> Result<(), Self::Error>

Start the name discovery procedure.

fn start_auto_connection_establishment<'a>(
    &mut self,
    params: &AutoConnectionEstablishmentParameters<'a>
) -> Result<(), Error<Self::Error>>

Start the auto connection establishment procedure.

fn start_general_connection_establishment(
    &mut self,
    params: &GeneralConnectionEstablishmentParameters
) -> Result<(), Self::Error>

Start a general connection establishment procedure.

fn start_selective_connection_establishment<'a>(
    &mut self,
    params: &SelectiveConnectionEstablishmentParameters<'a>
) -> Result<(), Error<Self::Error>>

Start a selective connection establishment procedure.

fn create_connection(
    &mut self,
    params: &ConnectionParameters
) -> Result<(), Self::Error>

Start the direct connection establishment procedure.

fn terminate_procedure(
    &mut self,
    procedure: Procedure
) -> Result<(), Error<Self::Error>>

The GAP procedure(s) specified is terminated.

fn start_connection_update(
    &mut self,
    params: &ConnectionUpdateParameters
) -> Result<(), Self::Error>

Start the connection update procedure.

fn send_pairing_request(
    &mut self,
    params: &PairingRequest
) -> Result<(), Self::Error>

Send the SM pairing request to start a pairing process. The authentication requirements and I/O capabilities should be set before issuing this command using the set_io_capability and set_authentication_requirement commands.

fn resolve_private_address(&mut self, addr: BdAddr) -> Result<(), Self::Error>

This command tries to resolve the address provided with the IRKs present in its database.

fn get_bonded_devices(&mut self) -> Result<(), Self::Error>

This command gets the list of the devices which are bonded. It returns the number of addresses and the corresponding address types and values.

fn set_broadcast_mode(
    &mut self,
    params: &BroadcastModeParameters
) -> Result<(), Error<Self::Error>>

This command puts the device into broadcast mode.

fn start_observation_procedure(
    &mut self,
    params: &ObservationProcedureParameters
) -> Result<(), Self::Error>

Starts an Observation procedure, when the device is in Observer Role.

fn is_device_bonded(&mut self, addr: PeerAddrType) -> Result<(), Self::Error>

The command finds whether the device, whose address is specified in the command, is bonded. If the device is using a resolvable private address and it has been bonded, then the command will return Success.

fn init_gap(
    &mut self,
    role: Role,
    privacy_enabled: bool,
    dev_name_characteristic_len: u8
) -> Result<(), Self::Error>

Register the GAP service with the GATT.

fn set_gap_event_mask(&mut self, flags: EventFlags) -> Result<(), Self::Error>

Allows masking events from the GAP.

impl<'bnrg, 'spi, 'dbuf, SPI, OutputPin1, OutputPin2, InputPin, SpiError, GpioError> Commands for ActiveBlueNRG<'bnrg, 'spi, 'dbuf, SPI, OutputPin1, OutputPin2, InputPin, GpioError> where
    SPI: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    OutputPin1: OutputPin<Error = GpioError>,
    OutputPin2: OutputPin<Error = GpioError>,
    InputPin: InputPin<Error = GpioError>, 

type Error = Error<SpiError, GpioError>

Type of communication errors.

fn init(&mut self) -> Result<(), Self::Error>

Initialize the GATT server on the slave device. Initialize all the pools and active nodes. Also it adds GATT service with service changed characteristic. Until this command is issued the GATT channel will not process any commands even if the connection is opened. This command has to be given before using any of the GAP features.

fn add_service(
    &mut self,
    params: &AddServiceParameters
) -> Result<(), Self::Error>

Add a service to GATT Server.

fn include_service(
    &mut self,
    params: &IncludeServiceParameters
) -> Result<(), Self::Error>

Include a service to another service.

fn add_characteristic(
    &mut self,
    params: &AddCharacteristicParameters
) -> Result<(), Self::Error>

Add a characteristic to a service.

fn add_characteristic_descriptor<'a>(
    &mut self,
    params: &AddDescriptorParameters<'a>
) -> Result<(), Error<Self::Error>>

Add a characteristic descriptor to a service.

fn update_characteristic_value<'a>(
    &mut self,
    params: &UpdateCharacteristicValueParameters<'a>
) -> Result<(), Error<Self::Error>>

Update a characteristic value in a service.

fn delete_characteristic(
    &mut self,
    service: ServiceHandle,
    characteristic: CharacteristicHandle
) -> Result<(), Self::Error>

Delete the characteristic specified from the service.

fn delete_service(&mut self, service: ServiceHandle) -> Result<(), Self::Error>

Delete the service specified from the GATT server database.

fn delete_included_service(
    &mut self,
    params: &DeleteIncludedServiceParameters
) -> Result<(), Self::Error>

Delete the Include definition from the service.

fn set_event_mask(&mut self, params: Event) -> Result<(), Self::Error>

Allows masking events from the GATT.

fn exchange_configuration(
    &mut self,
    conn_handle: ConnectionHandle
) -> Result<(), Self::Error>

Perform an ATT MTU exchange.

fn find_information_request(
    &mut self,
    conn_handle: ConnectionHandle,
    attribute_range: Range<CharacteristicHandle>
) -> Result<(), Self::Error>

Post the Find information request.

fn find_by_type_value_request<'a>(
    &mut self,
    params: &FindByTypeValueParameters<'a>
) -> Result<(), Error<Self::Error>>

Post the Find by type value request.

fn read_by_type_request(
    &mut self,
    params: &ReadByTypeParameters
) -> Result<(), Self::Error>

Send a Read By Type Request.

fn read_by_group_type_request(
    &mut self,
    params: &ReadByTypeParameters
) -> Result<(), Self::Error>

Sends a Read By Group Type request.

fn prepare_write_request<'a>(
    &mut self,
    params: &WriteRequest<'a>
) -> Result<(), Error<Self::Error>>

Sends a Prepare Write request.

fn execute_write_request(
    &mut self,
    conn_handle: ConnectionHandle
) -> Result<(), Self::Error>

Sends an Execute Write Request to write all pending prepared writes.

fn cancel_write_request(
    &mut self,
    conn_handle: ConnectionHandle
) -> Result<(), Self::Error>

Sends an Execute Write Request to discard prepared writes.

fn discover_all_primary_services(
    &mut self,
    conn_handle: ConnectionHandle
) -> Result<(), Self::Error>

This command will start the GATT client procedure to discover all primary services on the server.

fn discover_primary_services_by_uuid(
    &mut self,
    conn_handle: ConnectionHandle,
    uuid: Uuid
) -> Result<(), Self::Error>

This command will start the procedure to discover the primary services of the specified UUID on the server.

fn find_included_services(
    &mut self,
    conn_handle: ConnectionHandle,
    service_handle_range: Range<ServiceHandle>
) -> Result<(), Self::Error>

Start the procedure to find all included services.

fn discover_all_characteristics_of_service(
    &mut self,
    conn_handle: ConnectionHandle,
    attribute_handle_range: Range<CharacteristicHandle>
) -> Result<(), Self::Error>

Start the procedure to discover all the characteristics of a given service.

fn discover_characteristics_by_uuid(
    &mut self,
    conn_handle: ConnectionHandle,
    attribute_handle_range: Range<CharacteristicHandle>,
    uuid: Uuid
) -> Result<(), Self::Error>

Start the procedure to discover all the characteristics specified by the UUID.

fn discover_all_characteristic_descriptors(
    &mut self,
    conn_handle: ConnectionHandle,
    characteristic_handle_range: Range<CharacteristicHandle>
) -> Result<(), Self::Error>

Start the procedure to discover all characteristic descriptors on the server.

fn read_characteristic_value(
    &mut self,
    conn_handle: ConnectionHandle,
    characteristic_handle: CharacteristicHandle
) -> Result<(), Self::Error>

Start the procedure to read the attribute value.

fn read_characteristic_using_uuid(
    &mut self,
    conn_handle: ConnectionHandle,
    characteristic_handle_range: Range<CharacteristicHandle>,
    uuid: Uuid
) -> Result<(), Self::Error>

Start the procedure to read all the characteristics specified by the UUID.

fn read_long_characteristic_value(
    &mut self,
    params: &LongCharacteristicReadParameters
) -> Result<(), Self::Error>

Start the procedure to read a long characteristic value.

fn read_multiple_characteristic_values<'a>(
    &mut self,
    params: &MultipleCharacteristicReadParameters<'a>
) -> Result<(), Error<Self::Error>>

Start a procedure to read multiple characteristic values from a server.

fn write_characteristic_value<'a>(
    &mut self,
    params: &CharacteristicValue<'a>
) -> Result<(), Error<Self::Error>>

Start the procedure to write a characteristic value.

fn write_long_characteristic_value<'a>(
    &mut self,
    params: &LongCharacteristicValue<'a>
) -> Result<(), Error<Self::Error>>

Start the procedure to write a long characteristic value.

fn write_characteristic_value_reliably<'a>(
    &mut self,
    params: &LongCharacteristicValue<'a>
) -> Result<(), Error<Self::Error>>

Start the procedure to write a characteristic reliably.

fn write_long_characteristic_descriptor<'a>(
    &mut self,
    params: &LongCharacteristicValue<'a>
) -> Result<(), Error<Self::Error>>

Start the procedure to write a long characteristic descriptor.

fn read_long_characteristic_descriptor(
    &mut self,
    params: &LongCharacteristicReadParameters
) -> Result<(), Self::Error>

Start the procedure to read a long characteristic descriptor.

fn write_characteristic_descriptor<'a>(
    &mut self,
    params: &CharacteristicValue<'a>
) -> Result<(), Error<Self::Error>>

Start the procedure to write a characteristic descriptor value.

fn read_characteristic_descriptor(
    &mut self,
    conn_handle: ConnectionHandle,
    characteristic_handle: CharacteristicHandle
) -> Result<(), Self::Error>

Start the procedure to read a characteristic descriptor.

fn write_without_response<'a>(
    &mut self,
    params: &CharacteristicValue<'a>
) -> Result<(), Error<Self::Error>>

Start the procedure to write a characteristic value without waiting for any response from the server.

fn signed_write_without_response<'a>(
    &mut self,
    params: &CharacteristicValue<'a>
) -> Result<(), Error<Self::Error>>

Start the procedure to write a characteristic value with an authentication signature without waiting for any response from the server. It cannot be used when the link is encrypted.

fn confirm_indication(
    &mut self,
    conn_handle: ConnectionHandle
) -> Result<(), Self::Error>

Allow application to confirm indication. This command has to be sent when the application receives the GATT Indication event.

fn write_response<'a>(
    &mut self,
    params: &WriteResponseParameters<'a>
) -> Result<(), Error<Self::Error>>

Allows or rejects a write request from a client.

fn allow_read(
    &mut self,
    conn_handle: ConnectionHandle
) -> Result<(), Self::Error>

Allows the GATT server to send a response to a read request from a client.

fn set_security_permission(
    &mut self,
    params: &SecurityPermissionParameters
) -> Result<(), Self::Error>

This command sets the security permission for the attribute handle specified. Currently the setting of security permission is allowed only for client configuration descriptor.

fn set_descriptor_value<'a>(
    &mut self,
    params: &DescriptorValueParameters<'a>
) -> Result<(), Error<Self::Error>>

This command sets the value of a descriptor.

fn read_handle_value(
    &mut self,
    handle: CharacteristicHandle
) -> Result<(), Self::Error>

Reads the value of the attribute handle specified from the local GATT database.

fn read_handle_value_offset(
    &mut self,
    handle: CharacteristicHandle,
    offset: usize
) -> Result<(), Self::Error>

The command returns the value of the attribute handle from the specified offset.

fn update_long_characteristic_value<'a>(
    &mut self,
    params: &UpdateLongCharacteristicValueParameters<'a>
) -> Result<(), Error<Self::Error>>

Update the Attribute Value of a Characteristic belonging to a specified service.

fn init_gatt(&mut self) -> Result<(), Self::Error>

Initialize the GATT server on a slave device.

fn set_gatt_event_mask(&mut self, mask: Event) -> Result<(), Self::Error>

Allows masking events from the GATT.

impl<'bnrg, 'spi, 'dbuf, SPI, OutputPin1, OutputPin2, InputPin, SpiError, GpioError> Commands for ActiveBlueNRG<'bnrg, 'spi, 'dbuf, SPI, OutputPin1, OutputPin2, InputPin, GpioError> where
    SPI: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    OutputPin1: OutputPin<Error = GpioError>,
    OutputPin2: OutputPin<Error = GpioError>,
    InputPin: InputPin<Error = GpioError>, 

type Error = Error<SpiError, GpioError>

Type of communication errors.

fn get_firmware_revision(&mut self) -> Result<(), Self::Error>

This command is intended to retrieve the firmware revision number.

fn write_config_data(&mut self, params: &ConfigData) -> Result<(), Self::Error>

This command writes a value to a low level configure data structure. It is useful to setup directly some low level parameters for the system in the runtime.

fn read_config_data(
    &mut self,
    param: ConfigParameter
) -> Result<(), Self::Error>

This command requests the value in the low level configure data structure.

fn set_tx_power_level(&mut self, level: PowerLevel) -> Result<(), Self::Error>

This command sets the TX power level of the BlueNRG-MS.

fn device_standby(&mut self) -> Result<(), Self::Error>

Puts the device in standby mode.

fn get_tx_test_packet_count(&mut self) -> Result<(), Self::Error>

Retrieve the number of packets sent in the last TX direct test.

fn start_tone(&mut self, channel: u8) -> Result<(), Error<Self::Error>>

This command starts a carrier frequency, i.e. a tone, on a specific channel.

fn stop_tone(&mut self) -> Result<(), Self::Error>

Stops the previously started by the start_tone command.

fn get_link_status(&mut self) -> Result<(), Self::Error>

This command is intended to return the Link Layer Status and Connection Handles.

fn get_anchor_period(&mut self) -> Result<(), Self::Error>

This command is intended to retrieve information about the current Anchor Interval and allocable timing slots.

impl<'bnrg, 'spi, 'dbuf, SPI, OutputPin1, OutputPin2, InputPin, SpiError, GpioError> Commands for ActiveBlueNRG<'bnrg, 'spi, 'dbuf, SPI, OutputPin1, OutputPin2, InputPin, GpioError> where
    SPI: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    OutputPin1: OutputPin<Error = GpioError>,
    OutputPin2: OutputPin<Error = GpioError>,
    InputPin: InputPin<Error = GpioError>, 

type Error = Error<SpiError, GpioError>

Type of communication errors.

fn connection_parameter_update_request(
    &mut self,
    params: &ConnectionParameterUpdateRequest
) -> Result<(), Self::Error>

Send an L2CAP connection parameter update request from the peripheral to the central device.

fn connection_parameter_update_response(
    &mut self,
    params: &ConnectionParameterUpdateResponse
) -> Result<(), Self::Error>

This command should be sent in response to the L2CapConnectionUpdateResponse event from the controller. The accept parameter has to be set to true if the connection parameters given in the event are acceptable.

impl<'bnrg, 'spi, 'dbuf, SPI, OutputPin1, OutputPin2, InputPin, SpiError, GpioError> Controller for ActiveBlueNRG<'bnrg, 'spi, 'dbuf, SPI, OutputPin1, OutputPin2, InputPin, GpioError> where
    SPI: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    OutputPin1: OutputPin<Error = GpioError>,
    OutputPin2: OutputPin<Error = GpioError>,
    InputPin: InputPin<Error = GpioError>, 

type Error = Error<SpiError, GpioError>

Enumeration of [Controller] errors. These typically will be specializations of [host::uart::Error] that specify both the vendor-specific error type and a communication error type. The communication error type in turn will depend on the bus used to communicate with the controller as well as the device crate (e.g., [linux-embedded-hal::Spidev] uses [std::io::Error]).

type Header = CommandHeader

The type of header sent to the controller for HCI commands. Should be either [host::uart::CommandHeader], [host::cmd_link::Header], or [host::event_link::NoCommands], depending on the controller implementation.

type Vendor = BlueNRGTypes

Type containing vendor-specific extensions for the controller, including vendor-specific errors, events, and status codes.

fn write(&mut self, header: &[u8], payload: &[u8]) -> Result<(), Self::Error>

Writes the bytes to the controller, in a single transaction if possible. All of header shall be written, followed by all of payload. write is allowed to block internally, but should return [nb::Error::WouldBlock] if the controller is not ready to receive the data.

fn read_into(&mut self, buffer: &mut [u8]) -> Result<(), Self::Error>

Reads data from the controller into the provided buffer. The length of the buffer indicates the number of bytes to read. The implementor must not return bytes in an order different from that in which they were received from the controller. For example, the implementor may read all available bytes from the controller and maintain them in an internal buffer, but read_into shall only read the number of bytes requested.

fn peek(&mut self, n: usize) -> Result<u8, Self::Error>

Looks ahead at the data coming from the Controller without consuming it. Implementors should be able to support values of n up to 5 to support all potential data types.