55 lines
1.8 KiB
Rust
55 lines
1.8 KiB
Rust
use super::error::Error;
|
|
|
|
#[allow(dead_code)]
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub enum Channel {
|
|
One = 0,
|
|
Two = 1,
|
|
Three = 2,
|
|
Four = 3,
|
|
}
|
|
|
|
pub trait AttenuatorInterface {
|
|
fn modify(&mut self, attenuation: f32, channel: Channel) -> Result<f32, Error> {
|
|
if attenuation > 31.5 {
|
|
return Err(Error::Bounds);
|
|
}
|
|
|
|
// Calculate the attenuation code to program into the attenuator.
|
|
let attenuation_code = (attenuation * 2.0) as u8;
|
|
|
|
// Read all the channels, modify the channel of interest, and write all the channels back.
|
|
// This ensures the staging register and the output register are always in sync.
|
|
let mut channels = [0_u8; 4];
|
|
self.read_all(&mut channels)?;
|
|
channels[channel as usize] = attenuation_code;
|
|
self.write_all(&channels)?;
|
|
|
|
// Finally, latch the output of the updated channel to force it into an active state.
|
|
self.latch(channel)?;
|
|
|
|
Ok(attenuation_code as f32 / 2.0)
|
|
}
|
|
|
|
fn read(&mut self, channel: Channel) -> Result<f32, Error> {
|
|
let mut channels = [0_u8; 4];
|
|
|
|
// Reading the data always shifts data out of the staging registers, so we perform a
|
|
// duplicate write-back to ensure the staging register is always equal to the output
|
|
// register.
|
|
self.read_all(&mut channels)?;
|
|
self.write_all(&channels)?;
|
|
|
|
// Convert the desired channel code into dB of attenuation.
|
|
let attenuation_code = channels[channel as usize];
|
|
|
|
Ok(attenuation_code as f32 / 2.0)
|
|
}
|
|
|
|
fn reset(&mut self) -> Result<(), Error>;
|
|
|
|
fn latch(&mut self, channel: Channel) -> Result<(), Error>;
|
|
fn read_all(&mut self, channels: &mut [u8; 4]) -> Result<(), Error>;
|
|
fn write_all(&mut self, channels: &[u8; 4]) -> Result<(), Error>;
|
|
}
|