81 lines
2.5 KiB
Rust
81 lines
2.5 KiB
Rust
#![allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
|
|
|
|
use core::fmt;
|
|
use embedded_hal::blocking::spi::{Transfer, Write};
|
|
use embedded_hal::digital::v2::OutputPin;
|
|
|
|
use crate::bus::{Bus, FourWire, FourWireError};
|
|
|
|
// TODO This name is not ideal, should be renamed to VDM
|
|
/// This is just like [crate::bus::FourWire] but takes references instead of ownership
|
|
/// for the SPI bus and the ChipSelect pin
|
|
pub struct FourWireRef<'a, Spi: Transfer<u8> + Write<u8>, ChipSelect: OutputPin>(
|
|
FourWire<SpiRef<'a, Spi>, OutputPinRef<'a, ChipSelect>>,
|
|
);
|
|
|
|
impl<'a, Spi: Transfer<u8> + Write<u8>, ChipSelect: OutputPin> FourWireRef<'a, Spi, ChipSelect> {
|
|
pub fn new(spi: &'a mut Spi, cs: &'a mut ChipSelect) -> Self {
|
|
Self(FourWire::new(SpiRef(spi), OutputPinRef(cs)))
|
|
}
|
|
|
|
// this is actually a bit silly, but maybe someday someone finds this useful
|
|
pub fn release(self) -> (&'a mut Spi, &'a mut ChipSelect) {
|
|
let (spi_ref, cs_ref) = self.0.release();
|
|
(spi_ref.0, cs_ref.0)
|
|
}
|
|
}
|
|
|
|
impl<Spi: Transfer<u8> + Write<u8>, ChipSelect: OutputPin> Bus
|
|
for FourWireRef<'_, Spi, ChipSelect>
|
|
{
|
|
type Error =
|
|
FourWireError<<Spi as Transfer<u8>>::Error, <Spi as Write<u8>>::Error, ChipSelect::Error>;
|
|
|
|
#[inline]
|
|
fn read_frame(&mut self, block: u8, address: u16, data: &mut [u8]) -> Result<(), Self::Error> {
|
|
self.0.read_frame(block, address, data)
|
|
}
|
|
|
|
#[inline]
|
|
fn write_frame(&mut self, block: u8, address: u16, data: &[u8]) -> Result<(), Self::Error> {
|
|
self.0.write_frame(block, address, data)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct SpiRef<'a, Spi: Transfer<u8> + Write<u8>>(pub &'a mut Spi);
|
|
|
|
impl<'a, Spi: Transfer<u8> + Write<u8>> Transfer<u8> for SpiRef<'a, Spi> {
|
|
type Error = <Spi as Transfer<u8>>::Error;
|
|
|
|
#[inline]
|
|
fn transfer<'w>(&mut self, words: &'w mut [u8]) -> Result<&'w [u8], Self::Error> {
|
|
self.0.transfer(words)
|
|
}
|
|
}
|
|
|
|
impl<'a, Spi: Transfer<u8> + Write<u8>> Write<u8> for SpiRef<'a, Spi> {
|
|
type Error = <Spi as Write<u8>>::Error;
|
|
|
|
#[inline]
|
|
fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
|
|
self.0.write(words)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct OutputPinRef<'a, P: OutputPin>(pub &'a mut P);
|
|
|
|
impl<'a, P: OutputPin> OutputPin for OutputPinRef<'a, P> {
|
|
type Error = P::Error;
|
|
|
|
#[inline]
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
|
self.0.set_low()
|
|
}
|
|
|
|
#[inline]
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
|
self.0.set_high()
|
|
}
|
|
}
|