use core::future::Future;
use core::pin::pin;
use core::task::{Context, Waker};
use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
use embassy_sync::mutex::Mutex;
use sensor_db::mock::{AsyncFlash, MockFlash};
use sensor_db::{Error, SensorData, SensorDbAsync};
use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
#[derive(Debug, Clone, Copy, PartialEq, FromBytes, IntoBytes, KnownLayout, Immutable)]
#[repr(C)]
struct Temperature {
celsius_x100: i32,
}
impl SensorData for Temperature {
const SENSOR_ID: u16 = 0x01;
}
const PAGE: usize = 256;
const SECTOR: usize = 4096;
const SECTORS: usize = 16;
type Flash = AsyncFlash<MockFlash<PAGE, SECTOR>>;
type Db = SensorDbAsync<Flash, PAGE, SECTORS>;
type SharedDb = Mutex<CriticalSectionRawMutex, Db>;
const SAMPLES: u64 = 400;
fn run_both(a: impl Future<Output = ()>, b: impl Future<Output = ()>) {
let waker = Waker::noop();
let mut cx = Context::from_waker(waker);
let (mut a, mut b) = (pin!(a), pin!(b));
let (mut a_done, mut b_done) = (false, false);
while !(a_done && b_done) {
if !a_done {
a_done = a.as_mut().poll(&mut cx).is_ready();
}
if !b_done {
b_done = b.as_mut().poll(&mut cx).is_ready();
}
}
}
async fn sampler(db: &SharedDb, first: u64, count: u64) {
for i in 0..count {
let ts = first + i;
let mut db = db.lock().await;
db.append_sensor(
ts,
&Temperature {
celsius_x100: 2_000 + ts as i32,
},
)
.await
.expect("append");
}
}
async fn monitor(db: &SharedDb, polls: u32) -> u32 {
let mut highest = 0;
for _ in 0..polls {
let mut db = db.lock().await;
let count = db.count_sensor::<Temperature>().await.expect("count");
assert!(
count >= highest,
"an append-only log never counts backwards"
);
highest = count;
if let Some((header, value)) = db.latest_sensor::<Temperature>().await.expect("latest") {
assert_eq!(
value.celsius_x100,
2_000 + header.timestamp as i32,
"a read must return a reading someone actually wrote"
);
}
}
highest
}
fn main() -> Result<(), Error> {
println!("=== sharing one log between async tasks ===\n");
let flash = AsyncFlash::wrap(MockFlash::<PAGE, SECTOR>::new(SECTORS * SECTOR));
let mut db: Db = SensorDbAsync::new(flash, 0, SECTORS as u16, 2)?;
sensor_db::mock::block_on(db.format())?;
let shared: SharedDb = Mutex::new(db);
let mut observed = 0;
run_both(sampler(&shared, 0, SAMPLES), async {
observed = monitor(&shared, 150).await;
});
let mut db = shared.into_inner();
sensor_db::mock::block_on(db.sync())?;
println!(" sampler appended {SAMPLES}");
println!(" monitor observed up to {observed} while it ran");
println!(
" stored after sync {}",
sensor_db::mock::block_on(db.count_sensor::<Temperature>())?
);
assert_eq!(
sensor_db::mock::block_on(db.count_sensor::<Temperature>())?,
SAMPLES as u32,
"every append must be present"
);
let mut seen = vec![false; SAMPLES as usize];
sensor_db::mock::block_on(db.query_all_sensor::<Temperature, _>(|h, _| {
assert!(!seen[h.timestamp as usize], "no reading may appear twice");
seen[h.timestamp as usize] = true;
true
}))?;
assert!(seen.iter().all(|&s| s), "no reading may be missing");
println!(" every timestamp present exactly once");
println!("\nOK");
Ok(())
}