kirdy/src/laser_diode/ld_ctrl.rs

use stm32f4xx_hal::{
    gpio::{gpioa::*, gpiob::*, gpiod::*, Alternate, Output, PushPull},
    hal::{blocking::spi::Transfer, digital::v2::OutputPin},
    pac::SPI2,
    spi::{NoMiso, Spi, TransferModeNormal},
};

use uom::si::{
    ratio::ratio,
    f64::{ElectricPotential, ElectricCurrent},
};

use crate::laser_diode::max5719::{self, Dac};
use crate::laser_diode::laser_diode::TransimpedanceUnit;

pub trait ChannelPins {
    type CurrentSourceShort: OutputPin;
    type Max5719Load: OutputPin;
    type Max5719Cs: OutputPin;
    type Max5719Spi: Transfer<u8>;
}

pub struct LdCtrlPhy<C: ChannelPins> {
    pub dac: Dac<C::Max5719Spi, C::Max5719Cs, C::Max5719Load>,
    pub current_source_short_pin: C::CurrentSourceShort,
}
pub struct Channel0;

impl ChannelPins for Channel0 {
    type CurrentSourceShort = PA4<Output<PushPull>>;
    type Max5719Load = DacLoad;
    type Max5719Cs = DacCs;
    type Max5719Spi = DacSpi;
}

type DacSpi = Spi<SPI2, (PB10<Alternate<5>>, NoMiso, PB15<Alternate<5>>), TransferModeNormal>;
type DacCs = PD8<Output<PushPull>>;
type DacLoad = PB14<Output<PushPull>>;

pub struct LdCtrl{
    pub phy: LdCtrlPhy<Channel0>,
}

impl LdCtrl {
    pub fn new(phy_ch0: LdCtrlPhy<Channel0>) -> Self {
        LdCtrl {
            phy: phy_ch0,
        }
    }

    // LD Terminals are shorted together
    pub fn ld_short_enable(&mut self) {
        self.phy.current_source_short_pin.set_low();
    }

    // LD Current flows from anode to cathode
    pub fn ld_short_disable(&mut self) {
        self.phy.current_source_short_pin.set_high();
    }

    pub fn set_dac(&mut self, voltage: ElectricPotential, dac_out_v_max: ElectricPotential) -> ElectricPotential {
        let value = ((voltage / dac_out_v_max).get::<ratio>()
            * (max5719::MAX_VALUE as f64)) as u32;
        self.phy.dac.set(value).unwrap();
        voltage
    }

    pub fn set_i(&mut self, current: ElectricCurrent, transimpedance: TransimpedanceUnit, dac_out_v_max: ElectricPotential) -> ElectricCurrent {
        self.set_dac(current * transimpedance, dac_out_v_max) / transimpedance
    }
}