1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
#![no_std]
#![no_main]
use core::time::Duration;
use defmt::*;
use embassy_executor::Spawner;
use embassy_stm32::bind_interrupts;
use embassy_stm32::ipcc::{Config, ReceiveInterruptHandler, TransmitInterruptHandler};
use embassy_stm32::rcc::WPAN_DEFAULT;
use embassy_stm32_wpan::TlMbox;
use embassy_stm32_wpan::hci::BdAddr;
use embassy_stm32_wpan::hci::host::uart::UartHci;
use embassy_stm32_wpan::hci::host::{AdvertisingFilterPolicy, EncryptionKey, HostHci, OwnAddressType};
use embassy_stm32_wpan::hci::types::AdvertisingType;
use embassy_stm32_wpan::hci::vendor::command::gap::{AdvertisingDataType, DiscoverableParameters, GapCommands, Role};
use embassy_stm32_wpan::hci::vendor::command::gatt::GattCommands;
use embassy_stm32_wpan::hci::vendor::command::hal::{ConfigData, HalCommands, PowerLevel};
use embassy_stm32_wpan::lhci::LhciC1DeviceInformationCcrp;
use {defmt_rtt as _, panic_probe as _};
bind_interrupts!(struct Irqs{
IPCC_C1_RX => ReceiveInterruptHandler;
IPCC_C1_TX => TransmitInterruptHandler;
});
const BLE_GAP_DEVICE_NAME_LENGTH: u8 = 7;
#[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
async fn main(_spawner: Spawner) {
/*
How to make this work:
- Obtain a NUCLEO-STM32WB55 from your preferred supplier.
- Download and Install STM32CubeProgrammer.
- Download stm32wb5x_FUS_fw.bin, stm32wb5x_BLE_Mac_802_15_4_fw.bin, and Release_Notes.html from
gh:STMicroelectronics/STM32CubeWB@2234d97/Projects/STM32WB_Copro_Wireless_Binaries/STM32WB5x
- Open STM32CubeProgrammer
- On the right-hand pane, click "firmware upgrade" to upgrade the st-link firmware.
- Once complete, click connect to connect to the device.
- On the left hand pane, click the RSS signal icon to open "Firmware Upgrade Services".
- In the Release_Notes.html, find the memory address that corresponds to your device for the stm32wb5x_FUS_fw.bin file
- Select that file, the memory address, "verify download", and then "Firmware Upgrade".
- Once complete, in the Release_Notes.html, find the memory address that corresponds to your device for the
stm32wb5x_BLE_Mac_802_15_4_fw.bin file. It should not be the same memory address.
- Select that file, the memory address, "verify download", and then "Firmware Upgrade".
- Select "Start Wireless Stack".
- Disconnect from the device.
- Run this example.
Note: extended stack versions are not supported at this time. Do not attempt to install a stack with "extended" in the name.
*/
let mut config = embassy_stm32::Config::default();
config.rcc = WPAN_DEFAULT;
let p = embassy_stm32::init(config);
info!("Hello World!");
let config = Config::default();
let mbox = TlMbox::init(p.IPCC, Irqs, config).await;
let mut sys = mbox.sys_subsystem;
let mut ble = mbox.ble_subsystem;
let _ = sys.shci_c2_ble_init(Default::default()).await;
info!("resetting BLE...");
ble.reset().await;
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
info!("config public address...");
ble.write_config_data(&ConfigData::public_address(get_bd_addr()).build())
.await;
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
info!("config random address...");
ble.write_config_data(&ConfigData::random_address(get_random_addr()).build())
.await;
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
info!("config identity root...");
ble.write_config_data(&ConfigData::identity_root(&get_irk()).build())
.await;
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
info!("config encryption root...");
ble.write_config_data(&ConfigData::encryption_root(&get_erk()).build())
.await;
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
info!("config tx power level...");
ble.set_tx_power_level(PowerLevel::ZerodBm).await;
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
info!("GATT init...");
ble.init_gatt().await;
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
info!("GAP init...");
ble.init_gap(Role::PERIPHERAL, false, BLE_GAP_DEVICE_NAME_LENGTH).await;
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
// info!("set scan response...");
// ble.le_set_scan_response_data(&[]).await.unwrap();
// let response = ble.read().await.unwrap();
// defmt::info!("{}", response);
info!("set discoverable...");
ble.set_discoverable(&DiscoverableParameters {
advertising_type: AdvertisingType::NonConnectableUndirected,
advertising_interval: Some((Duration::from_millis(250), Duration::from_millis(250))),
address_type: OwnAddressType::Public,
filter_policy: AdvertisingFilterPolicy::AllowConnectionAndScan,
local_name: None,
advertising_data: &[],
conn_interval: (None, None),
})
.await
.unwrap();
let response = ble.read().await;
defmt::info!("{}", response);
// remove some advertisement to decrease the packet size
info!("delete tx power ad type...");
ble.delete_ad_type(AdvertisingDataType::TxPowerLevel).await;
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
info!("delete conn interval ad type...");
ble.delete_ad_type(AdvertisingDataType::PeripheralConnectionInterval)
.await;
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
info!("update advertising data...");
ble.update_advertising_data(&eddystone_advertising_data())
.await
.unwrap();
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
info!("update advertising data type...");
ble.update_advertising_data(&[3, AdvertisingDataType::UuidCompleteList16 as u8, 0xaa, 0xfe])
.await
.unwrap();
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
info!("update advertising data flags...");
ble.update_advertising_data(&[
2,
AdvertisingDataType::Flags as u8,
(0x02 | 0x04) as u8, // BLE general discoverable, without BR/EDR support
])
.await
.unwrap();
let response = ble.read().await.unwrap();
defmt::info!("{}", response);
cortex_m::asm::wfi();
}
fn get_bd_addr() -> BdAddr {
let mut bytes = [0u8; 6];
let lhci_info = LhciC1DeviceInformationCcrp::new();
bytes[0] = (lhci_info.uid64 & 0xff) as u8;
bytes[1] = ((lhci_info.uid64 >> 8) & 0xff) as u8;
bytes[2] = ((lhci_info.uid64 >> 16) & 0xff) as u8;
bytes[3] = lhci_info.device_type_id;
bytes[4] = (lhci_info.st_company_id & 0xff) as u8;
bytes[5] = (lhci_info.st_company_id >> 8 & 0xff) as u8;
BdAddr(bytes)
}
fn get_random_addr() -> BdAddr {
let mut bytes = [0u8; 6];
let lhci_info = LhciC1DeviceInformationCcrp::new();
bytes[0] = (lhci_info.uid64 & 0xff) as u8;
bytes[1] = ((lhci_info.uid64 >> 8) & 0xff) as u8;
bytes[2] = ((lhci_info.uid64 >> 16) & 0xff) as u8;
bytes[3] = 0;
bytes[4] = 0x6E;
bytes[5] = 0xED;
BdAddr(bytes)
}
const BLE_CFG_IRK: [u8; 16] = [
0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
];
const BLE_CFG_ERK: [u8; 16] = [
0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21, 0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21,
];
fn get_irk() -> EncryptionKey {
EncryptionKey(BLE_CFG_IRK)
}
fn get_erk() -> EncryptionKey {
EncryptionKey(BLE_CFG_ERK)
}
fn eddystone_advertising_data() -> [u8; 24] {
const EDDYSTONE_URL: &[u8] = b"www.rust-lang.com";
let mut service_data = [0u8; 24];
let url_len = EDDYSTONE_URL.len();
service_data[0] = 6 + url_len as u8;
service_data[1] = AdvertisingDataType::ServiceData as u8;
// 16-bit eddystone uuid
service_data[2] = 0xaa;
service_data[3] = 0xFE;
service_data[4] = 0x10; // URL frame type
service_data[5] = 22_i8 as u8; // calibrated TX power at 0m
service_data[6] = 0x03; // eddystone url prefix = https
service_data[7..(7 + url_len)].copy_from_slice(EDDYSTONE_URL);
service_data
}
|
