an.tsouchlos/commonsense-sw
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Compare commits

base: an.tsouchlos:ae7bd7b92121d37d673577e8c5c3e6e1aab3378a
Branches Tags
an.tsouchlos:master
an.tsouchlos:feature/nRF52-DK
an.tsouchlos:v1.0
..
compare: an.tsouchlos:629396e40432764ee1c95b2050b4441ec3c57669
Branches Tags
an.tsouchlos:feature/nRF52-DK
an.tsouchlos:master
an.tsouchlos:v1.0

No commits in common. "ae7bd7b92121d37d673577e8c5c3e6e1aab3378a" and "629396e40432764ee1c95b2050b4441ec3c57669" have entirely different histories.
ae7bd7b921 ... 629396e404

4 changed files with 116 additions and 289 deletions
Show Stats Expand all files Collapse all files

8
Cargo.toml
View File

@ -23,11 +23,3 @@ nrf-softdevice = { version = "0.1.0", features = ["defmt", "ble-peripheral", "bl
nrf-softdevice-s112 = "0.1.2" nrf-softdevice-s112 = "0.1.2"
panic-probe = { version = "0.3.2", features = ["print-defmt"] } panic-probe = { version = "0.3.2", features = ["print-defmt"] }
static_cell = "2.1.0" static_cell = "2.1.0"
[[bin]]
name = "commonsense"
path = "src/bin/temp_rh_measurement.rs"
test = false
doctest = false
bench = false

3
memory.x
View File

@ -1,7 +1,8 @@
MEMORY MEMORY
{ {
/* NOTE 1 K = 1 KiB = 1024 bytes */ /* NOTE 1 K = 1 KiB = 1024 bytes */
/* These values correspond to the NRF52832 with SoftDevice S112 v7.x */ /* These values correspond to the NRF52810 with SoftDevice S112 v7.x */
FLASH : ORIGIN = 0x00000000 + 100K, LENGTH = 192K - 100K FLASH : ORIGIN = 0x00000000 + 100K, LENGTH = 192K - 100K
RAM : ORIGIN = 0x20000000 + 0x24b8, LENGTH = 24K - 0x24b8 RAM : ORIGIN = 0x20000000 + 0x24b8, LENGTH = 24K - 0x24b8
} }

192
src/bin/ble_gatt_server.rs
View File

@ -61,100 +61,102 @@ async fn main(spawner: Spawner) {
let mut led = Output::new(p.P0_18, Level::Low, OutputDrive::Standard); let mut led = Output::new(p.P0_18, Level::Low, OutputDrive::Standard);
led.set_high(); led.set_high();
let config = nrf_softdevice::Config { info!("Hello World!");
clock: Some(raw::nrf_clock_lf_cfg_t {
source: raw::NRF_CLOCK_LF_SRC_RC as u8,
rc_ctiv: 16,
rc_temp_ctiv: 2,
accuracy: raw::NRF_CLOCK_LF_ACCURACY_500_PPM as u8,
}),
conn_gap: Some(raw::ble_gap_conn_cfg_t {
conn_count: 1,
event_length: 24,
}),
conn_gatt: Some(raw::ble_gatt_conn_cfg_t { att_mtu: 256 }),
gatts_attr_tab_size: Some(raw::ble_gatts_cfg_attr_tab_size_t {
attr_tab_size: raw::BLE_GATTS_ATTR_TAB_SIZE_DEFAULT,
}),
gap_role_count: Some(raw::ble_gap_cfg_role_count_t {
adv_set_count: 1,
periph_role_count: 1,
// central_role_count: 3,
// central_sec_count: 0,
// _bitfield_1: raw::ble_gap_cfg_role_count_t::new_bitfield_1(0),
}),
gap_device_name: Some(raw::ble_gap_cfg_device_name_t {
p_value: b"HelloRust" as *const u8 as _,
current_len: 9,
max_len: 9,
write_perm: unsafe { mem::zeroed() },
_bitfield_1: raw::ble_gap_cfg_device_name_t::new_bitfield_1(
raw::BLE_GATTS_VLOC_STACK as u8,
),
}),
..Default::default()
};
let sd = Softdevice::enable(&config); // let config = nrf_softdevice::Config {
let server = unwrap!(Server::new(sd)); // clock: Some(raw::nrf_clock_lf_cfg_t {
unwrap!(spawner.spawn(softdevice_task(sd))); // source: raw::NRF_CLOCK_LF_SRC_RC as u8,
// rc_ctiv: 16,
static ADV_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new() // rc_temp_ctiv: 2,
.flags(&[Flag::GeneralDiscovery, Flag::LE_Only]) // accuracy: raw::NRF_CLOCK_LF_ACCURACY_500_PPM as u8,
.services_16(ServiceList::Complete, &[ServiceUuid16::BATTERY]) // }),
.full_name("HelloRust") // conn_gap: Some(raw::ble_gap_conn_cfg_t {
.build(); // conn_count: 1,
// event_length: 24,
static SCAN_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new() // }),
.services_128( // conn_gatt: Some(raw::ble_gatt_conn_cfg_t { att_mtu: 256 }),
ServiceList::Complete, // gatts_attr_tab_size: Some(raw::ble_gatts_cfg_attr_tab_size_t {
&[0x9e7312e0_2354_11eb_9f10_fbc30a62cf38_u128.to_le_bytes()], // attr_tab_size: raw::BLE_GATTS_ATTR_TAB_SIZE_DEFAULT,
) // }),
.build(); // gap_role_count: Some(raw::ble_gap_cfg_role_count_t {
// adv_set_count: 1,
loop { // periph_role_count: 1,
info!("Creating config"); // // central_role_count: 3,
let config = peripheral::Config::default(); // // central_sec_count: 0,
info!("Creating adv object"); // // _bitfield_1: raw::ble_gap_cfg_role_count_t::new_bitfield_1(0),
let adv = peripheral::ConnectableAdvertisement::ScannableUndirected { // }),
adv_data: &ADV_DATA, // gap_device_name: Some(raw::ble_gap_cfg_device_name_t {
scan_data: &SCAN_DATA, // p_value: b"HelloRust" as *const u8 as _,
}; // current_len: 9,
info!("Starting advertising"); // max_len: 9,
let conn = unwrap!(peripheral::advertise_connectable(sd, adv, &config).await); // write_perm: unsafe { mem::zeroed() },
// _bitfield_1: raw::ble_gap_cfg_device_name_t::new_bitfield_1(
info!("advertising done!"); // raw::BLE_GATTS_VLOC_STACK as u8,
// ),
// Run the GATT server on the connection. This returns when the connection gets disconnected. // }),
// // ..Default::default()
// Event enums (ServerEvent's) are generated by nrf_softdevice::gatt_server // };
// proc macro when applied to the Server struct above //
let e = gatt_server::run(&conn, &server, |e| match e { // let sd = Softdevice::enable(&config);
ServerEvent::Bas(e) => match e { // let server = unwrap!(Server::new(sd));
BatteryServiceEvent::BatteryLevelCccdWrite { notifications } => { // unwrap!(spawner.spawn(softdevice_task(sd)));
info!("battery notifications: {}", notifications) //
} // static ADV_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new()
}, // .flags(&[Flag::GeneralDiscovery, Flag::LE_Only])
ServerEvent::Foo(e) => match e { // .services_16(ServiceList::Complete, &[ServiceUuid16::BATTERY])
FooServiceEvent::FooWrite(val) => { // .full_name("HelloRust")
info!("wrote foo: {}", val); // .build();
if let Err(e) = server.foo.foo_notify(&conn, &(val + 1)) { //
info!("send notification error: {:?}", e); // static SCAN_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new()
} // .services_128(
} // ServiceList::Complete,
FooServiceEvent::FooCccdWrite { // &[0x9e7312e0_2354_11eb_9f10_fbc30a62cf38_u128.to_le_bytes()],
indications, // )
notifications, // .build();
} => { //
info!( // loop {
"foo indications: {}, notifications: {}", // info!("Creating config");
indications, notifications // let config = peripheral::Config::default();
) // info!("Creating adv object");
} // let adv = peripheral::ConnectableAdvertisement::ScannableUndirected {
}, // adv_data: &ADV_DATA,
}) // scan_data: &SCAN_DATA,
.await; // };
// info!("Starting advertising");
info!("gatt_server run exited with error: {:?}", e); // let conn = unwrap!(peripheral::advertise_connectable(sd, adv, &config).await);
} //
// info!("advertising done!");
//
// // Run the GATT server on the connection. This returns when the connection gets disconnected.
// //
// // Event enums (ServerEvent's) are generated by nrf_softdevice::gatt_server
// // proc macro when applied to the Server struct above
// let e = gatt_server::run(&conn, &server, |e| match e {
// ServerEvent::Bas(e) => match e {
// BatteryServiceEvent::BatteryLevelCccdWrite { notifications } => {
// info!("battery notifications: {}", notifications)
// }
// },
// ServerEvent::Foo(e) => match e {
// FooServiceEvent::FooWrite(val) => {
// info!("wrote foo: {}", val);
// if let Err(e) = server.foo.foo_notify(&conn, &(val + 1)) {
// info!("send notification error: {:?}", e);
// }
// }
// FooServiceEvent::FooCccdWrite {
// indications,
// notifications,
// } => {
// info!(
// "foo indications: {}, notifications: {}",
// indications, notifications
// )
// }
// },
// })
// .await;
//
// info!("gatt_server run exited with error: {:?}", e);
// }
} }

202
src/bin/temp_rh_measurement.rs
View File

@ -1,213 +1,45 @@
#![no_std] #![no_std]
#![no_main] #![no_main]
use static_cell::StaticCell;
use core::mem;
use embassy_nrf::interrupt::{self, InterruptExt};
use embassy_nrf::peripherals::TWI0;
use embassy_time::Timer; use embassy_time::Timer;
use nrf_softdevice::ble::advertisement_builder::{
Flag, LegacyAdvertisementBuilder, LegacyAdvertisementPayload, ServiceList, ServiceUuid16,
};
use nrf_softdevice::ble::{gatt_server, peripheral, TxPower};
use nrf_softdevice::{raw, Softdevice}; use nrf_softdevice::{raw, Softdevice};
use defmt::*; use defmt::*;
use embassy_executor::Spawner; use embassy_executor::Spawner;
use embassy_nrf::gpio::{Level, Output, OutputDrive}; use embassy_nrf::twim::{self, Twim};
use embassy_nrf::twim;
use embassy_nrf::{bind_interrupts, peripherals}; use embassy_nrf::{bind_interrupts, peripherals};
use {defmt_rtt as _, panic_probe as _}; use {defmt_rtt as _, panic_probe as _};
// const ADDRESS: u8 = 0x44;
//
// BLE code
//
//
#[nrf_softdevice::gatt_service(uuid = "181a")] bind_interrupts!(struct Irqs {
struct EnvironmentalService { TWIM0_TWIS0_TWI0 => twim::InterruptHandler<peripherals::TWI0>;
#[characteristic(uuid = "2a6e", read, notify)] });
temperature: u32,
#[characteristic(uuid = "2a6f", read, notify)]
humidity: u32,
}
#[nrf_softdevice::gatt_server] #[embassy_executor::main]
struct Server { async fn main(_spawner: Spawner) {
bas: EnvironmentalService, let p = embassy_nrf::init(Default::default());
}
#[embassy_executor::task] info!("Initializing TWI...");
async fn softdevice_task(sd: &'static Softdevice) -> ! {
sd.run().await
}
#[embassy_executor::task] let config = twim::Config::default();
async fn ble_task(sd: &'static Softdevice, server: &'static Server) { let mut twi = Twim::new(p.TWI0, Irqs, p.P0_14, p.P0_13, config);
static ADV_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new()
.flags(&[Flag::GeneralDiscovery, Flag::LE_Only])
.services_16(ServiceList::Complete, &[ServiceUuid16::BATTERY])
.full_name("CommonSense")
.build();
static SCAN_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new()
.services_128(
ServiceList::Complete,
&[0x9e7312e0_2354_11eb_9f10_fbc30a62cf38_u128.to_le_bytes()],
)
.build();
loop { loop {
let config = peripheral::Config { unwrap!(twi.blocking_write(ADDRESS, &mut [0xFD]));
tx_power: TxPower::Plus4dBm,
..Default::default()
};
let adv = peripheral::ConnectableAdvertisement::ScannableUndirected {
adv_data: &ADV_DATA,
scan_data: &SCAN_DATA,
};
let conn = unwrap!(peripheral::advertise_connectable(sd, adv, &config).await);
let _e = gatt_server::run(&conn, server, |_| {}).await;
Timer::after_secs(10).await;
}
}
//
//
// Sensing code
//
//
struct GenericTempHumiditySensor<T: twim::Instance> {
address: u8,
driver: twim::Twim<'static, T>,
}
// TODO: Implement CRC checks
impl<T: twim::Instance> GenericTempHumiditySensor<T> {
fn new(address: u8, driver: twim::Twim<'static, T>) -> Self {
Self { address, driver }
}
/// The procedure for reading out the temperature and humidity and converting them to floats is
/// detailed in the datasheet of the SHT41-AD1B-R2.
async fn read_temp_and_humidity(&mut self) -> (f32, f32) {
let mut buf = [0u8; 6];
unwrap!(self.driver.blocking_write(self.address, &mut [0xFD]));
Timer::after_millis(10).await; Timer::after_millis(10).await;
unwrap!(self.driver.blocking_read(self.address, &mut buf));
let mut buf = [0u8; 6];
unwrap!(twi.blocking_read(ADDRESS, &mut buf));
let temp_int = u16::from_be_bytes([buf[0], buf[1]]); let temp_int = u16::from_be_bytes([buf[0], buf[1]]);
let temp_float: f32 = -45f32 + 175f32 * (temp_int as f32 / (2u32.pow(16) - 1) as f32); let temp_float: f32 = -45f32 + 175f32 * (temp_int as f32 / (2u32.pow(16) - 1) as f32);
let rh_int = u16::from_be_bytes([buf[3], buf[4]]); let rh_int = u16::from_be_bytes([buf[3], buf[4]]);
let rh_float: f32 = -6f32 + 125f32 * (rh_int as f32 / (2u32.pow(16) - 1) as f32); let rh_float: f32 = -6f32 + 125f32 * (rh_int as f32 / (2u32.pow(16) - 1) as f32);
println!("{}\t{}", temp_float, rh_float);
return (temp_float, rh_float); Timer::after_millis(50).await;
}
}
bind_interrupts!(struct Irqs {
TWIM0_TWIS0_TWI0 => twim::InterruptHandler<peripherals::TWI0>;
});
type TempHumiditySensor = GenericTempHumiditySensor<TWI0>;
#[embassy_executor::task]
async fn measurement_task(mut sensor: TempHumiditySensor, server: &'static Server) {
loop {
let (temp, humidity) = sensor.read_temp_and_humidity().await;
println!("{} °C\t{} %", temp, humidity);
let temp: u32 = (temp * 100.0) as u32;
let humidity: u32 = (humidity * 100.0) as u32;
unwrap!(server.bas.temperature_set(&temp));
unwrap!(server.bas.humidity_set(&humidity));
Timer::after_secs(5).await;
}
}
//
//
// Main code
//
//
static SERVER: StaticCell<Server> = StaticCell::new();
#[embassy_executor::main]
async fn main(spawner: Spawner) {
// Set up peripherals
interrupt::TWIM0_TWIS0_TWI0.set_priority(interrupt::Priority::P2);
let mut embassy_config = embassy_nrf::config::Config::default();
embassy_config.gpiote_interrupt_priority = interrupt::Priority::P2;
embassy_config.time_interrupt_priority = interrupt::Priority::P2;
let p = embassy_nrf::init(embassy_config);
let config = twim::Config::default();
let twi = twim::Twim::new(p.TWI0, Irqs, p.P0_14, p.P0_13, config);
let sensor = TempHumiditySensor::new(0x44, twi);
let mut led = Output::new(p.P0_20, Level::Low, OutputDrive::Standard);
// Set up softdevice
let config = nrf_softdevice::Config {
clock: Some(raw::nrf_clock_lf_cfg_t {
source: raw::NRF_CLOCK_LF_SRC_RC as u8,
rc_ctiv: 16,
rc_temp_ctiv: 2,
accuracy: raw::NRF_CLOCK_LF_ACCURACY_500_PPM as u8,
}),
conn_gap: Some(raw::ble_gap_conn_cfg_t {
conn_count: 1,
event_length: 24,
}),
conn_gatt: Some(raw::ble_gatt_conn_cfg_t { att_mtu: 256 }),
gatts_attr_tab_size: Some(raw::ble_gatts_cfg_attr_tab_size_t {
attr_tab_size: raw::BLE_GATTS_ATTR_TAB_SIZE_DEFAULT,
}),
gap_role_count: Some(raw::ble_gap_cfg_role_count_t {
adv_set_count: 1,
periph_role_count: 1,
}),
gap_device_name: Some(raw::ble_gap_cfg_device_name_t {
p_value: b"CommonSense" as *const u8 as _,
current_len: 9,
max_len: 9,
write_perm: unsafe { mem::zeroed() },
_bitfield_1: raw::ble_gap_cfg_device_name_t::new_bitfield_1(
raw::BLE_GATTS_VLOC_STACK as u8,
),
}),
..Default::default()
};
let sd = Softdevice::enable(&config);
let server = unwrap!(Server::new(sd));
let server: &'static mut Server = SERVER.init(server);
// Start tasks
unwrap!(spawner.spawn(softdevice_task(sd)));
unwrap!(spawner.spawn(ble_task(sd, server)));
unwrap!(spawner.spawn(measurement_task(sensor, server)));
loop {
led.set_high();
Timer::after_millis(500).await;
led.set_low();
Timer::after_millis(500).await;
} }
} }