ad57xx 0.3.0

Analog Devices AD57xx SPI DAC driver
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Quad channel implementation
use bitfield_struct::bitfield;
use embedded_hal::spi::{Operation, SpiDevice};

use crate::{
    Ad57xx, Ad57xxShared, Command, Data, Error, Config, Function
};

/// Dac Channel
#[derive(Debug, Clone, Copy)]
#[repr(u8)]
pub enum ChannelQuad {
    /// DAC Channel A
    DacA = 0,
    /// DAC Channel B
    DacB = 1,
    /// DAC Channel C
    DacC = 2,
    /// DAC Channel D
    DacD = 3,
    /// All DAC Channels
    AllDacs = 4,
}
impl From<ChannelQuad> for u8 {
    fn from(value: ChannelQuad) -> Self {
        match value {
            ChannelQuad::DacA => 0,
            ChannelQuad::DacB => 1,
            ChannelQuad::DacC => 2,
            ChannelQuad::DacD => 3,
            ChannelQuad::AllDacs => 4,
        }
    }
}
/// Definition of the power configuration register
#[bitfield(u16)]
pub struct PowerConfigQuad {
    #[bits(1)]
    pu_a: bool,
    #[bits(1)]
    pu_b: bool,
    #[bits(1)]
    pu_c: bool,
    #[bits(1)]
    pu_d: bool,
    #[bits(1)]
    _unused: bool,
    #[bits(1)]
    tsd: bool,
    #[bits(1)]
    _unused: bool,
    #[bits(1)]
    oc_a: bool,
    #[bits(1)]
    oc_b: bool,
    #[bits(1)]
    oc_c: bool,
    #[bits(1)]
    oc_d: bool,
    #[bits(5)]
    _unused: u8,
}

impl<DEV, E> Ad57xxShared<DEV, crate::marker::Ad57x4>
where
    DEV: SpiDevice<Error = E>,
{
    /// Create a new quad channel AD57xx DAC SPI Device on a shared bus
    pub fn new_ad57x4(spi: DEV) -> Self {
        Self::create(spi)
    }
    /// Power up or down a single or all DAC channels
    /// After power up a timeout of 10us is required before loading the corresponding DAC register
    pub fn set_power(&mut self, chan: ChannelQuad, pwr: bool) -> Result<(), Error<E>> {
        let pcfg = PowerConfigQuad::from(self.pcfg);
        self.pcfg = match chan {
                ChannelQuad::DacA => pcfg.with_pu_a(pwr),
                ChannelQuad::DacB => pcfg.with_pu_b(pwr),
                ChannelQuad::DacC => pcfg.with_pu_c(pwr),
                ChannelQuad::DacD => pcfg.with_pu_d(pwr),
                ChannelQuad::AllDacs => pcfg
                    .with_pu_a(pwr)
                    .with_pu_b(pwr)
                    .with_pu_c(pwr)
                    .with_pu_d(pwr),
        }.into();
        self.write(Command::<ChannelQuad>::PowerControlRegister, Data::PowerControl(self.pcfg.into()))
    }    

}

impl<DEV, E> Ad57xx<DEV, E> for Ad57xxShared<DEV, crate::marker::Ad57x4> where
DEV: SpiDevice<Error = E>{
    type CH = ChannelQuad;
    type PCFG = PowerConfigQuad;
    fn spi_write(&mut self, payload: &[u8; 3]) -> Result<(), Error<E>> {
        self.spi
            .transaction(&mut [Operation::Write(payload)])
            .map_err(Error::Spi)
    }
    fn spi_read(&mut self, cmd: u8) -> Result<u16, Error<E>> {
        self.spi.write(&[cmd, 0, 0]).map_err(Error::Spi)?;
        let mut rx: [u8; 3] = [0x00; 3];
        // Send a NOP instruction (0x18) while reading
        self.spi
            .transfer(&mut rx, &mut [0x18, 0, 0])
            .map_err(Error::Spi)?;
        Ok(((rx[1] as u16) << 8) | rx[0] as u16)
    }    
    /// Set the device configuration
    fn set_config(&mut self, cfg: Config) -> Result<(), Error<E>> {
        self.cfg = cfg;
        self.write(
            Command::<Self::CH>::ControlRegister(Function::Config),
            Data::Control(cfg),
        )
    }

    /// Get the device configuration
    #[cfg(not(feature = "readback"))]
    fn get_config(&mut self) -> Result<Config, Error<E>> {
        Ok(self.cfg)
    }
    #[cfg(feature = "readback")]
    fn get_config(&mut self) -> Result<Config, Error<E>> {
        match self.read(Command::<Self::CH>::ControlRegister(Function::Config))? {
            Data::Control(cfg) => {self.cfg = cfg; Ok(cfg)},
            _ => Err(Error::ReadError),
        }
    }

    /// Set the device power configuration
    fn set_power_config(&mut self, pcfg: Self::PCFG) -> Result<(), Error<E>> {
        self.pcfg = pcfg.into();
        self.write(Command::PowerControlRegister, Data::PowerControl(pcfg))
    }

    /// Get the device power configuration
    #[cfg(not(feature = "readback"))]
    fn get_power_config(&mut self) -> Result<Self::PCFG, Error<E>> {
        Ok(self.pcfg.into())
    }
    #[cfg(feature = "readback")]
    fn get_power_config(&mut self) -> Result<Self::PCFG, Error<E>> {
        if let Data::PowerControl(pcfg) = self.read(Command::PowerControlRegister)? {
            self.pcfg = pcfg.into();
            Ok(pcfg)
        } else {
            Err(Error::ReadError)
        }
    }
}