use crate::error::Error;
use crate::port::{LogSink, LogSinkAsync, LogSinkAsyncExt, LogSinkExt};
use crate::typed::SensorData;
use zerocopy::{Immutable, IntoBytes};
pub struct SensorLogger<L, Clock>
where
Clock: Fn() -> u64,
{
sink: L,
clock: Clock,
}
impl<L, Clock> SensorLogger<L, Clock>
where
L: LogSink,
Clock: Fn() -> u64,
{
pub fn new(sink: L, clock: Clock) -> Self {
Self { sink, clock }
}
pub fn log<T: SensorData>(&mut self, data: &T) -> Result<(), Error> {
let ts = (self.clock)();
self.sink.append_sensor(ts, data)
}
pub fn log_raw(&mut self, sensor_id: u16, payload: &[u8]) -> Result<(), Error> {
let ts = (self.clock)();
self.sink.append(sensor_id, ts, payload)
}
pub fn log_value<T: IntoBytes + Immutable>(
&mut self,
sensor_id: u16,
data: &T,
) -> Result<(), Error> {
let ts = (self.clock)();
self.sink.append_value(sensor_id, ts, data)
}
pub fn sync(&mut self) -> Result<(), Error> {
self.sink.sync()
}
pub fn sink(&self) -> &L {
&self.sink
}
pub fn sink_mut(&mut self) -> &mut L {
&mut self.sink
}
pub fn into_inner(self) -> (L, Clock) {
(self.sink, self.clock)
}
}
pub struct SensorLoggerAsync<L, Clock>
where
Clock: Fn() -> u64,
{
sink: L,
clock: Clock,
}
impl<L, Clock> SensorLoggerAsync<L, Clock>
where
L: LogSinkAsync,
Clock: Fn() -> u64,
{
pub fn new(sink: L, clock: Clock) -> Self {
Self { sink, clock }
}
pub async fn log<T: SensorData>(&mut self, data: &T) -> Result<(), Error> {
let ts = (self.clock)();
self.sink.append_sensor(ts, data).await
}
pub async fn log_raw(&mut self, sensor_id: u16, payload: &[u8]) -> Result<(), Error> {
let ts = (self.clock)();
self.sink.append(sensor_id, ts, payload).await
}
pub async fn log_value<T: IntoBytes + Immutable>(
&mut self,
sensor_id: u16,
data: &T,
) -> Result<(), Error> {
let ts = (self.clock)();
self.sink.append_value(sensor_id, ts, data).await
}
pub async fn sync(&mut self) -> Result<(), Error> {
self.sink.sync().await
}
pub fn sink_mut(&mut self) -> &mut L {
&mut self.sink
}
pub fn sink(&self) -> &L {
&self.sink
}
pub fn into_inner(self) -> (L, Clock) {
(self.sink, self.clock)
}
}
#[cfg(all(test, feature = "std"))]
mod tests {
extern crate alloc;
use super::*;
use crate::db::SensorDb;
use crate::mock::MockFlash;
use core::cell::Cell;
use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
const PAGE: usize = 256;
const SECTOR: usize = 4096;
const SECTORS: usize = 8;
type Db = SensorDb<MockFlash<PAGE, SECTOR>, PAGE, SECTORS>;
#[derive(Debug, Clone, Copy, PartialEq, FromBytes, IntoBytes, KnownLayout, Immutable)]
#[repr(C)]
struct Temperature {
celsius: f32,
}
impl SensorData for Temperature {
const SENSOR_ID: u16 = 0x01;
}
fn make_logger(start: u64) -> SensorLogger<Db, impl Fn() -> u64> {
let flash = MockFlash::<PAGE, SECTOR>::new(SECTORS * SECTOR);
let mut db = SensorDb::new(flash, 0, SECTORS as u16, 1).unwrap();
db.format().unwrap();
let counter = Cell::new(start);
SensorLogger::new(db, move || {
let ts = counter.get();
counter.set(ts + 1000);
ts
})
}
#[test]
fn log_and_retrieve() {
let mut logger = make_logger(1000);
logger.log(&Temperature { celsius: 25.5 }).unwrap();
logger.sync().unwrap();
let (hdr, temp) = logger
.sink_mut()
.latest_sensor::<Temperature>()
.unwrap()
.unwrap();
assert_eq!(hdr.timestamp, 1000);
assert_eq!(temp.celsius, 25.5);
}
#[test]
fn log_raw_and_retrieve() {
let mut logger = make_logger(5000);
logger.log_raw(0x42, &[0xDE, 0xAD]).unwrap();
logger.sync().unwrap();
let mut buf = [0u8; 16];
let (hdr, n) = logger.sink_mut().latest(0x42, &mut buf).unwrap().unwrap();
assert_eq!(hdr.timestamp, 5000);
assert_eq!(&buf[..n], &[0xDE, 0xAD]);
}
#[test]
fn multiple_logs_increment_timestamp() {
let mut logger = make_logger(0);
for i in 0..5 {
logger
.log(&Temperature {
celsius: i as f32 * 10.0,
})
.unwrap();
}
logger.sync().unwrap();
let (hdr, temp) = logger
.sink_mut()
.latest_sensor::<Temperature>()
.unwrap()
.unwrap();
assert_eq!(hdr.timestamp, 4000);
assert_eq!(temp.celsius, 40.0);
assert_eq!(
logger
.sink_mut()
.count(Some(Temperature::SENSOR_ID))
.unwrap(),
5
);
}
#[test]
fn db_access_for_queries() {
let mut logger = make_logger(100);
logger.log(&Temperature { celsius: 20.0 }).unwrap();
logger.log(&Temperature { celsius: 21.0 }).unwrap();
logger.log(&Temperature { celsius: 22.0 }).unwrap();
logger.sync().unwrap();
assert!(logger.sink().is_mounted());
assert_eq!(logger.sink().stats().total_entries, 3);
let mut readings = alloc::vec::Vec::new();
logger
.sink_mut()
.query_all_sensor::<Temperature, _>(|hdr, temp| {
readings.push((hdr.timestamp, temp.celsius));
true
})
.unwrap();
assert_eq!(readings.len(), 3);
assert_eq!(readings[0], (100, 20.0));
assert_eq!(readings[1], (1100, 21.0));
assert_eq!(readings[2], (2100, 22.0));
}
#[test]
fn into_inner_returns_db_and_clock() {
let logger = make_logger(0);
let (db, clock) = logger.into_inner();
assert!(db.is_mounted());
assert_eq!(clock(), 0);
}
#[test]
fn logger_db_immutable_reads() {
let mut logger = make_logger(1000);
logger.log(&Temperature { celsius: 20.0 }).unwrap();
logger.log(&Temperature { celsius: 25.0 }).unwrap();
logger.log(&Temperature { celsius: 30.0 }).unwrap();
logger.sync().unwrap();
let (hdr, temp) = logger
.sink_mut()
.latest_sensor::<Temperature>()
.unwrap()
.unwrap();
assert_eq!(hdr.timestamp, 3000);
assert_eq!(temp.celsius, 30.0);
let (hdr, temp) = logger
.sink_mut()
.oldest_sensor::<Temperature>()
.unwrap()
.unwrap();
assert_eq!(hdr.timestamp, 1000);
assert_eq!(temp.celsius, 20.0);
assert_eq!(logger.sink_mut().count_sensor::<Temperature>().unwrap(), 3);
assert_eq!(logger.sink_mut().count(None).unwrap(), 3);
}
}
#[cfg(all(test, feature = "std", feature = "async"))]
mod async_tests {
extern crate alloc;
use super::*;
use crate::async_db::SensorDbAsync;
use crate::mock::MockFlash;
use core::cell::Cell;
use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
const PAGE: usize = 256;
const SECTOR: usize = 4096;
const SECTORS: usize = 8;
#[derive(Debug, Clone, Copy, PartialEq, FromBytes, IntoBytes, KnownLayout, Immutable)]
#[repr(C)]
struct Temperature {
celsius: f32,
}
impl SensorData for Temperature {
const SENSOR_ID: u16 = 0x01;
}
struct MockFlashAsync<const P: usize, const S: usize> {
inner: MockFlash<P, S>,
}
impl<const P: usize, const S: usize> MockFlashAsync<P, S> {
fn new(size: usize) -> Self {
Self {
inner: MockFlash::<P, S>::new(size),
}
}
}
impl<const P: usize, const S: usize> embedded_storage_async::nor_flash::ErrorType
for MockFlashAsync<P, S>
{
type Error = crate::mock::MockFlashError;
}
impl<const P: usize, const S: usize> embedded_storage_async::nor_flash::ReadNorFlash
for MockFlashAsync<P, S>
{
const READ_SIZE: usize = 1;
async fn read(&mut self, offset: u32, buf: &mut [u8]) -> Result<(), Self::Error> {
use embedded_storage::nor_flash::ReadNorFlash;
self.inner.read(offset, buf)
}
fn capacity(&self) -> usize {
use embedded_storage::nor_flash::ReadNorFlash;
self.inner.capacity()
}
}
impl<const P: usize, const S: usize> embedded_storage_async::nor_flash::NorFlash
for MockFlashAsync<P, S>
{
const WRITE_SIZE: usize = P;
const ERASE_SIZE: usize = S;
async fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
use embedded_storage::nor_flash::NorFlash;
self.inner.erase(from, to)
}
async fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
use embedded_storage::nor_flash::NorFlash;
self.inner.write(offset, bytes)
}
}
#[allow(unsafe_code, clippy::never_loop)]
fn block_on<T>(fut: impl core::future::Future<Output = T>) -> T {
use core::pin::pin;
use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
fn dummy_raw_waker() -> RawWaker {
fn no_op(_: *const ()) {}
fn clone(data: *const ()) -> RawWaker {
RawWaker::new(data, &VTABLE)
}
const VTABLE: RawWakerVTable = RawWakerVTable::new(clone, no_op, no_op, no_op);
RawWaker::new(core::ptr::null(), &VTABLE)
}
let waker = unsafe { Waker::from_raw(dummy_raw_waker()) };
let mut cx = Context::from_waker(&waker);
let mut fut = pin!(fut);
loop {
match fut.as_mut().poll(&mut cx) {
Poll::Ready(val) => return val,
Poll::Pending => panic!("async operation returned Pending in sync mock"),
}
}
}
fn make_async_logger(
start: u64,
) -> SensorLoggerAsync<
SensorDbAsync<MockFlashAsync<PAGE, SECTOR>, PAGE, SECTORS>,
impl Fn() -> u64,
> {
let flash = MockFlashAsync::<PAGE, SECTOR>::new(SECTORS * SECTOR);
let mut db = SensorDbAsync::new(flash, 0, SECTORS as u16, 1).unwrap();
block_on(db.format()).unwrap();
let counter = Cell::new(start);
SensorLoggerAsync::new(db, move || {
let ts = counter.get();
counter.set(ts + 1000);
ts
})
}
#[test]
fn async_log_and_retrieve() {
let mut logger = make_async_logger(1000);
block_on(logger.log(&Temperature { celsius: 25.5 })).unwrap();
block_on(logger.sync()).unwrap();
let (hdr, temp) = block_on(logger.sink_mut().latest_sensor::<Temperature>())
.unwrap()
.unwrap();
assert_eq!(hdr.timestamp, 1000);
assert_eq!(temp.celsius, 25.5);
}
#[test]
fn async_log_raw_and_retrieve() {
let mut logger = make_async_logger(5000);
block_on(logger.log_raw(0x42, &[0xDE, 0xAD])).unwrap();
block_on(logger.sync()).unwrap();
let mut buf = [0u8; 16];
let (hdr, n) = block_on(logger.sink_mut().latest(0x42, &mut buf))
.unwrap()
.unwrap();
assert_eq!(hdr.timestamp, 5000);
assert_eq!(&buf[..n], &[0xDE, 0xAD]);
}
#[test]
fn async_multiple_logs_increment_timestamp() {
let mut logger = make_async_logger(0);
for i in 0..5 {
block_on(logger.log(&Temperature {
celsius: i as f32 * 10.0,
}))
.unwrap();
}
block_on(logger.sync()).unwrap();
let (hdr, temp) = block_on(logger.sink_mut().latest_sensor::<Temperature>())
.unwrap()
.unwrap();
assert_eq!(hdr.timestamp, 4000);
assert_eq!(temp.celsius, 40.0);
assert_eq!(
block_on(logger.sink_mut().count(Some(Temperature::SENSOR_ID))).unwrap(),
5
);
}
#[test]
fn async_db_access() {
let mut logger = make_async_logger(100);
block_on(logger.log(&Temperature { celsius: 20.0 })).unwrap();
block_on(logger.log(&Temperature { celsius: 21.0 })).unwrap();
block_on(logger.log(&Temperature { celsius: 22.0 })).unwrap();
block_on(logger.sync()).unwrap();
assert!(logger.sink().is_mounted());
assert_eq!(logger.sink().stats().total_entries, 3);
let mut readings = alloc::vec::Vec::new();
block_on(
logger
.sink_mut()
.query_all_sensor::<Temperature, _>(|hdr, temp| {
readings.push((hdr.timestamp, temp.celsius));
true
}),
)
.unwrap();
assert_eq!(readings.len(), 3);
assert_eq!(readings[0], (100, 20.0));
assert_eq!(readings[1], (1100, 21.0));
assert_eq!(readings[2], (2100, 22.0));
}
#[test]
fn async_into_inner_returns_db_and_clock() {
let logger = make_async_logger(0);
let (db, clock) = logger.into_inner();
assert!(db.is_mounted());
assert_eq!(clock(), 0);
}
}