rename project
This commit is contained in:
@@ -1,219 +0,0 @@
|
||||
use embassy_time::Timer;
|
||||
use trouble_host::prelude::*;
|
||||
use esp_radio::ble::controller::BleConnector;
|
||||
use log::{warn,info};
|
||||
use embassy_futures::join::join;
|
||||
use embassy_futures::select::select;
|
||||
|
||||
|
||||
/// Max number of connections
|
||||
const CONNECTIONS_MAX: usize = 1;
|
||||
|
||||
/// Max number of L2CAP channels.
|
||||
const L2CAP_CHANNELS_MAX: usize = 2; // Signal + att
|
||||
|
||||
// GATT Server definition
|
||||
#[gatt_server]
|
||||
struct Server {
|
||||
battery_service: BatteryService,
|
||||
engine_speed_service: EngineSpeedService,
|
||||
}
|
||||
|
||||
/// Battery service
|
||||
#[gatt_service(uuid = service::BATTERY)]
|
||||
struct BatteryService {
|
||||
/// Battery Level
|
||||
#[descriptor(uuid = descriptors::VALID_RANGE, read, value = [0, 100])]
|
||||
#[descriptor(uuid = descriptors::MEASUREMENT_DESCRIPTION, name = "hello", read, value = "Battery Level")]
|
||||
#[characteristic(uuid = characteristic::BATTERY_LEVEL, read, notify, value = 10)]
|
||||
level: u8,
|
||||
#[characteristic(uuid = "408813df-5dd4-1f87-ec11-cdb001100000", write, read, notify)]
|
||||
status: bool,
|
||||
}
|
||||
|
||||
#[gatt_service(uuid = "e000adbf-3508-435b-9638-eaff1d5e7c7e")]
|
||||
struct EngineSpeedService {
|
||||
/// Battery Level
|
||||
// #[descriptor(uuid = descriptors::VALID_RANGE, read, value = [0, 100])]
|
||||
// #[descriptor(uuid = descriptors::MEASUREMENT_DESCRIPTION, name = "hello", read, value = "Battery Level")]
|
||||
#[characteristic(uuid = characteristic::ROTATIONAL_SPEED, read, notify, value = 1200)]
|
||||
rpm: i32,
|
||||
}
|
||||
|
||||
|
||||
pub async fn run_ble(peripheral : esp_hal::peripherals::BT<'_>) {
|
||||
let radio_init = esp_radio::init().expect("Failed to initialize Wi-Fi/BLE controller");
|
||||
let connector = BleConnector::new(&radio_init, peripheral, Default::default()).expect("connector");
|
||||
let controller: ExternalController<_, 20> = ExternalController::new(connector);
|
||||
|
||||
// Using a fixed "random" address can be useful for testing. In real scenarios, one would
|
||||
// use e.g. the MAC 6 byte array as the address (how to get that varies by the platform).
|
||||
let address: Address = Address::random([0xff, 0x8f, 0x1a, 0x05, 0xe4, 0xff]);
|
||||
info!("Our address = {:?}", address);
|
||||
|
||||
let mut resources: HostResources<DefaultPacketPool, CONNECTIONS_MAX, L2CAP_CHANNELS_MAX> = HostResources::new();
|
||||
let stack = trouble_host::new(controller, &mut resources).set_random_address(address);
|
||||
let Host {
|
||||
mut peripheral, runner, ..
|
||||
} = stack.build();
|
||||
|
||||
info!("Starting advertising and GATT service");
|
||||
let server = Server::new_with_config(GapConfig::Peripheral(PeripheralConfig {
|
||||
name: "ECUlogical",
|
||||
appearance: &appearance::power_device::GENERIC_POWER_DEVICE,
|
||||
}))
|
||||
.unwrap();
|
||||
|
||||
let _ = join(
|
||||
ble_task(runner),
|
||||
async {
|
||||
loop {
|
||||
match advertise("Trouble Example", &mut peripheral, &server).await {
|
||||
Ok(conn) => {
|
||||
// set up tasks when the connection is established to a central, so they don't run when no one is connected.
|
||||
let a = gatt_events_task(&server, &conn);
|
||||
let b = custom_task(&server, &conn, &stack);
|
||||
// run until any task ends (usually because the connection has been closed),
|
||||
// then return to advertising state.
|
||||
select(a, b).await;
|
||||
}
|
||||
Err(e) => {
|
||||
panic!("[adv] error: {:?}", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
.await;
|
||||
}
|
||||
|
||||
/// This is a background task that is required to run forever alongside any other BLE tasks.
|
||||
///
|
||||
/// ## Alternative
|
||||
///
|
||||
/// If you didn't require this to be generic for your application, you could statically spawn this with i.e.
|
||||
///
|
||||
/// ```rust,ignore
|
||||
///
|
||||
/// #[embassy_executor::task]
|
||||
/// async fn ble_task(mut runner: Runner<'static, SoftdeviceController<'static>>) {
|
||||
/// runner.run().await;
|
||||
/// }
|
||||
///
|
||||
/// spawner.must_spawn(ble_task(runner));
|
||||
/// ```
|
||||
async fn ble_task<C: Controller, P: PacketPool>(mut runner: Runner<'_, C, P>) {
|
||||
loop {
|
||||
if let Err(e) = runner.run().await {
|
||||
panic!("[ble_task] error: {:?}", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Stream Events until the connection closes.
|
||||
///
|
||||
/// This function will handle the GATT events and process them.
|
||||
/// This is how we interact with read and write requests.
|
||||
async fn gatt_events_task<P: PacketPool>(server: &Server<'_>, conn: &GattConnection<'_, '_, P>) -> Result<(), Error> {
|
||||
let level = server.battery_service.level;
|
||||
let reason = loop {
|
||||
match conn.next().await {
|
||||
GattConnectionEvent::Disconnected { reason } => break reason,
|
||||
GattConnectionEvent::Gatt { event } => {
|
||||
match &event {
|
||||
// are these clauses important? they don't do anything
|
||||
// except log
|
||||
GattEvent::Read(event) => {
|
||||
if event.handle() == level.handle {
|
||||
let value = server.get(&level);
|
||||
info!("[gatt] Read Event to Level Characteristic: {:?}", value);
|
||||
}
|
||||
}
|
||||
GattEvent::Write(event) => {
|
||||
if event.handle() == level.handle {
|
||||
info!("[gatt] Write Event to Level Characteristic: {:?}", event.data());
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
};
|
||||
// This step is also performed at drop(), but writing it explicitly is necessary
|
||||
// in order to ensure reply is sent.
|
||||
match event.accept() {
|
||||
Ok(reply) => reply.send().await,
|
||||
Err(e) => warn!("[gatt] error sending response: {:?}", e),
|
||||
};
|
||||
}
|
||||
_ => {} // ignore other Gatt Connection Events
|
||||
}
|
||||
};
|
||||
info!("[gatt] disconnected: {:?}", reason);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Create an advertiser to use to connect to a BLE Central, and wait for it to connect.
|
||||
async fn advertise<'values, 'server, C: Controller>(
|
||||
name: &'values str,
|
||||
peripheral: &mut Peripheral<'values, C, DefaultPacketPool>,
|
||||
server: &'server Server<'values>,
|
||||
) -> Result<GattConnection<'values, 'server, DefaultPacketPool>, BleHostError<C::Error>> {
|
||||
let mut advertiser_data = [0; 31];
|
||||
let len = AdStructure::encode_slice(
|
||||
&[
|
||||
AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED),
|
||||
AdStructure::ServiceUuids16(&[[0x0f, 0x18]]),
|
||||
AdStructure::CompleteLocalName(name.as_bytes()),
|
||||
],
|
||||
&mut advertiser_data[..],
|
||||
)?;
|
||||
let advertiser = peripheral
|
||||
.advertise(
|
||||
&Default::default(),
|
||||
Advertisement::ConnectableScannableUndirected {
|
||||
adv_data: &advertiser_data[..len],
|
||||
scan_data: &[],
|
||||
},
|
||||
)
|
||||
.await?;
|
||||
info!("[adv] advertising");
|
||||
let conn = advertiser.accept().await?.with_attribute_server(server)?;
|
||||
info!("[adv] connection established");
|
||||
Ok(conn)
|
||||
}
|
||||
|
||||
/// Example task to use the BLE notifier interface.
|
||||
/// This task will notify the connected central of a counter value every 2 seconds.
|
||||
/// It will also read the RSSI value every 2 seconds.
|
||||
/// and will stop when the connection is closed by the central or an error occurs.
|
||||
async fn custom_task<C: Controller, P: PacketPool>(
|
||||
server: &Server<'_>,
|
||||
conn: &GattConnection<'_, '_, P>,
|
||||
stack: &Stack<'_, C, P>,
|
||||
) {
|
||||
let mut tick: u8 = 0;
|
||||
let level = server.battery_service.level;
|
||||
let rpm = server.engine_speed_service.rpm;
|
||||
loop {
|
||||
tick = tick.wrapping_add(1);
|
||||
info!("[custom_task] notifying connection of tick {}", tick);
|
||||
|
||||
// if the characteristic does not support notifications,
|
||||
// this would return an error. Use `set` instead, in that case.
|
||||
// See inline comments in trouble-host/src/attribute.rs around
|
||||
// line 631
|
||||
|
||||
if level.notify(conn, &tick).await.is_err() {
|
||||
info!("[custom_task] error notifying connection");
|
||||
break;
|
||||
};
|
||||
// read RSSI (Received Signal Strength Indicator) of the connection.
|
||||
if let Ok(rssi) = conn.raw().rssi(stack).await {
|
||||
info!("[custom_task] RSSI: {:?}", rssi);
|
||||
} else {
|
||||
info!("[custom_task] error getting RSSI");
|
||||
break;
|
||||
};
|
||||
let new_rpm = 1200 + 20 * i32::from(tick);
|
||||
rpm.notify(conn, &new_rpm).await.expect("failed to notify");
|
||||
|
||||
Timer::after_secs(2).await;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user