kirdy/src/laser_diode/ld_drive.rs

use miniconf::Miniconf;
use crate::laser_diode::current_sources::CurrentSource;
use core::{marker::PhantomData, f64::NAN};

use uom::si::{
    electric_current::milliampere,
    f64::{ElectricPotential, ElectricCurrent, Power},
};

use uom::{si::{ISQ, SI, Quantity}, typenum::*};

// Volt / Ampere
pub type TransimpedanceUnit = Quantity<ISQ<P2, P1, N3, N2, Z0, Z0, Z0>, SI<f64>, f64>;
// Ampere / Volt
type TransconductanceUnit = Quantity<ISQ<N2, N1, P3, P2, Z0, Z0, Z0>, SI<f64>, f64>;
// Watt / Ampere
pub type IToPowerUnit = Quantity<ISQ<P2, P1, N3, N1, Z0, Z0, Z0>, SI<f64>, f64>; 

impl Settings{
    pub const DAC_OUT_V_MAX: ElectricPotential = ElectricPotential {
        dimension: PhantomData,
        units: PhantomData,
        value: 4.096,
    };

    // Unit: A/V
    const PD_MON_TRANSCONDUCTANCE: TransconductanceUnit = TransconductanceUnit {
        dimension: PhantomData,
        units: PhantomData,
        value: 0.001,
    };

    const LD_DRIVE_TRANSIMPEDANCE: TransimpedanceUnit = TransimpedanceUnit {
        dimension: PhantomData,
        units: PhantomData,
        value: 10.0 / 0.75,
    };
}

#[derive(Clone, Debug, Miniconf)]
pub struct Settings {
    ld_drive_current: ElectricCurrent,
    pd_i_to_out_pwr: IToPowerUnit,
}

impl Default for Settings {
    fn default() -> Self {
        Self {
            ld_drive_current: ElectricCurrent::new::<milliampere>(0.0),
            pd_i_to_out_pwr: IToPowerUnit {dimension: PhantomData, units: PhantomData, value: NAN}
        }
    }
}

pub struct LdDrive{
    ctrl: CurrentSource,
    settings: Settings,
}

impl LdDrive{
    pub fn new(current_source: CurrentSource)-> Self{
        LdDrive {
            ctrl: current_source,
            settings: Settings::default()
        }
    }

    pub fn setup(&mut self) {
        self.power_down();
        self.ld_set_i(ElectricCurrent::new::<milliampere>(0.0));
        self.ld_short();
    }

    pub fn power_up(&mut self){
        self.ctrl.power_up();
    }

    pub fn power_down(&mut self){
        self.ctrl.power_down();
    }

    pub fn get_ld_drive_current(&mut self) -> ElectricCurrent{
        self.settings.ld_drive_current
    }

    pub fn set_pd_i_to_out_pwr(&mut self, val: IToPowerUnit){
        self.settings.pd_i_to_out_pwr = val;
    }

    pub fn ld_short(&mut self) {
        self.ctrl.ld_short_enable();
    }

    pub fn ld_open(&mut self) {
        self.ctrl.ld_short_disable();
    }

    pub fn get_ld_power_output(&mut self) -> Power {
        let pd_i = self.get_pd_i();
        pd_i * self.settings.pd_i_to_out_pwr
    }

    pub fn get_pd_i(&mut self) -> ElectricCurrent {
        self.ctrl.get_pd_mon_v() * Settings::PD_MON_TRANSCONDUCTANCE
    }

    pub fn ld_set_i(&mut self, i: ElectricCurrent) -> ElectricCurrent {
        let ld_i_set = self.ctrl.set_i(i, Settings::LD_DRIVE_TRANSIMPEDANCE, Settings::DAC_OUT_V_MAX);
        self.settings.ld_drive_current = ld_i_set;
        ld_i_set
    }
}