119 lines
3.2 KiB
Rust
119 lines
3.2 KiB
Rust
use miniconf::Miniconf;
|
|
use crate::laser_diode::ld_ctrl::LdCtrl;
|
|
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,
|
|
ld_drive_current_limit: ElectricCurrent,
|
|
pd_i_to_out_pwr: IToPowerUnit,
|
|
}
|
|
|
|
impl Default for Settings {
|
|
fn default() -> Self {
|
|
Self {
|
|
ld_drive_current: ElectricCurrent::new::<milliampere>(0.0),
|
|
ld_drive_current_limit: ElectricCurrent::new::<milliampere>(0.0),
|
|
pd_i_to_out_pwr: IToPowerUnit {dimension: PhantomData, units: PhantomData, value: NAN}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct LdDrive{
|
|
ctrl: LdCtrl,
|
|
settings: Settings,
|
|
}
|
|
|
|
impl LdDrive{
|
|
pub fn new(current_source: LdCtrl)-> 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_ld_drive_current_limit(&mut self, i_limit: ElectricCurrent){
|
|
self.settings.ld_drive_current_limit = i_limit;
|
|
}
|
|
|
|
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 = i.min(self.settings.ld_drive_current_limit);
|
|
let ld_i_set = self.ctrl.set_i(ld_i_set, Settings::LD_DRIVE_TRANSIMPEDANCE, Settings::DAC_OUT_V_MAX);
|
|
self.settings.ld_drive_current = ld_i_set;
|
|
ld_i_set
|
|
}
|
|
} |