st7305_lcd/cmd/

power.rs

use crate::{command::WriteCommand, instr::Instr};

macro_rules! millivolt_value {
    (
        $(#[$meta:meta])*
        $name:ident: $min:literal ..= $max:literal,
        zero = $zero:literal,
        step = $step:literal
    ) => {
        $(#[$meta])*
        #[derive(Clone, Copy, Debug, PartialEq, Eq)]
        pub struct $name(u8);

        impl $name {
            #[doc = concat!(
                "Voltage in millivolts, ", stringify!($min), " to ", stringify!($max),
                " in steps of ", stringify!($step), " mV.\n\n# Panics\n\n",
                "If `mv` is out of range or not on a step (at compile time in a `const`)."
            )]
            pub const fn from_mv(mv: i16) -> Self {
                assert!(
                    mv >= $min && mv <= $max && (mv - $zero) % $step == 0,
                    concat!(stringify!($name), " out of range")
                );
                Self(((mv - $zero).unsigned_abs() / $step) as u8)
            }
        }
    };
}

/// `GCTRL` (§8.2.10): gate voltages VGH and VGL.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct GateVoltageControl {
    vgha: Vgh,
    vgla: Vgl,
}

impl GateVoltageControl {
    /// Register default: VGH 15 V, VGL -10 V.
    pub const DEFAULT: Self = Self {
        vgha: Vgh::from_mv(15_000),
        vgla: Vgl::from_mv(-10_000),
    };

    /// `VGHA[4:0]`.
    #[must_use]
    pub const fn with_vgh(mut self, v: Vgh) -> Self {
        self.vgha = v;
        self
    }

    /// `VGLA[4:0]`.
    #[must_use]
    pub const fn with_vgl(mut self, v: Vgl) -> Self {
        self.vgla = v;
        self
    }

    const fn bytes(&self) -> [u8; 2] {
        [self.vgha.0, self.vgla.0]
    }
}

impl Default for GateVoltageControl {
    fn default() -> Self {
        Self::DEFAULT
    }
}

impl WriteCommand for GateVoltageControl {
    const OPCODE: Instr = Instr::GCTRL;
    type Params = [u8; 2];
    fn params(&self) -> Self::Params {
        self.bytes()
    }
}

millivolt_value!(
    /// Gate high voltage VGH.
    Vgh: 8_000..=17_000, zero = 8_000, step = 500
);
millivolt_value!(
    /// Gate low voltage VGL.
    Vgl: -15_000..=-6_000, zero = -5_000, step = 500
);

const _: () = assert!(matches!(GateVoltageControl::DEFAULT.bytes(), [0x0E, 0x0A]));
const _: () = assert!(matches!(
    GateVoltageControl::DEFAULT
        .with_vgh(Vgh::from_mv(8_000))
        .with_vgl(Vgl::from_mv(-6_000))
        .bytes(),
    [0x00, 0x02]
));
const _: () = assert!(matches!(
    GateVoltageControl::DEFAULT
        .with_vgh(Vgh::from_mv(17_000))
        .with_vgl(Vgl::from_mv(-15_000))
        .bytes(),
    [0x12, 0x14]
));

/// `VSHPCTRL` (§8.2.11): source high positive voltage of the four source
/// voltage sets (see [`SourceVoltageSelect`]).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SourceHighPositiveVoltageControl {
    vshpa: [SourceHighPositiveVoltage; 4],
}

impl SourceHighPositiveVoltageControl {
    /// Register default: 5.0 V in all four sets.
    pub const DEFAULT: Self = Self {
        vshpa: [
            SourceHighPositiveVoltage::from_mv(5_000),
            SourceHighPositiveVoltage::from_mv(5_000),
            SourceHighPositiveVoltage::from_mv(5_000),
            SourceHighPositiveVoltage::from_mv(5_000),
        ],
    };

    /// `VSHPA1..=4`.
    #[must_use]
    pub const fn with_vshpa(mut self, v: [SourceHighPositiveVoltage; 4]) -> Self {
        self.vshpa = v;
        self
    }

    const fn bytes(&self) -> [u8; 4] {
        [
            self.vshpa[0].0,
            self.vshpa[1].0,
            self.vshpa[2].0,
            self.vshpa[3].0,
        ]
    }
}

impl Default for SourceHighPositiveVoltageControl {
    fn default() -> Self {
        Self::DEFAULT
    }
}

impl WriteCommand for SourceHighPositiveVoltageControl {
    const OPCODE: Instr = Instr::VSHPCTRL;
    type Params = [u8; 4];
    fn params(&self) -> Self::Params {
        self.bytes()
    }
}

millivolt_value!(
    /// Source high positive voltage VSHPAx.
    SourceHighPositiveVoltage: 3_700..=6_200, zero = 3_700, step = 20
);

const _: () = assert!(matches!(
    SourceHighPositiveVoltageControl::DEFAULT.bytes(),
    [0x41, 0x41, 0x41, 0x41]
));
const _: () = assert!(matches!(
    SourceHighPositiveVoltageControl {
        vshpa: [
            SourceHighPositiveVoltage::from_mv(3_700),
            SourceHighPositiveVoltage::from_mv(6_200),
            SourceHighPositiveVoltage::from_mv(5_800),
            SourceHighPositiveVoltage::from_mv(5_820)
        ]
    }
    .bytes(),
    [0x00, 0x7D, 0x69, 0x6A]
));

/// `VSLPCTRL` (§8.2.12): source low positive voltage of the four source
/// voltage sets (see [`SourceVoltageSelect`]).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SourceLowPositiveVoltageControl {
    vslpa: [SourceLowPositiveVoltage; 4],
}

impl SourceLowPositiveVoltageControl {
    /// Register default: 1.0 V in all four sets.
    pub const DEFAULT: Self = Self {
        vslpa: [
            SourceLowPositiveVoltage::from_mv(1_000),
            SourceLowPositiveVoltage::from_mv(1_000),
            SourceLowPositiveVoltage::from_mv(1_000),
            SourceLowPositiveVoltage::from_mv(1_000),
        ],
    };

    /// `VSLPA1..=4`.
    #[must_use]
    pub const fn with_vslpa(mut self, v: [SourceLowPositiveVoltage; 4]) -> Self {
        self.vslpa = v;
        self
    }

    const fn bytes(&self) -> [u8; 4] {
        [
            self.vslpa[0].0,
            self.vslpa[1].0,
            self.vslpa[2].0,
            self.vslpa[3].0,
        ]
    }
}

impl Default for SourceLowPositiveVoltageControl {
    fn default() -> Self {
        Self::DEFAULT
    }
}

impl WriteCommand for SourceLowPositiveVoltageControl {
    const OPCODE: Instr = Instr::VSLPCTRL;
    type Params = [u8; 4];
    fn params(&self) -> Self::Params {
        self.bytes()
    }
}

millivolt_value!(
    /// Source low positive voltage VSLPAx.
    SourceLowPositiveVoltage: 0..=2_000, zero = 0, step = 20
);

const _: () = assert!(matches!(
    SourceLowPositiveVoltageControl::DEFAULT.bytes(),
    [0x32, 0x32, 0x32, 0x32]
));
const _: () = assert!(matches!(
    SourceLowPositiveVoltageControl {
        vslpa: [
            SourceLowPositiveVoltage::from_mv(0),
            SourceLowPositiveVoltage::from_mv(2_000),
            SourceLowPositiveVoltage::from_mv(500),
            SourceLowPositiveVoltage::from_mv(520)
        ]
    }
    .bytes(),
    [0x00, 0x64, 0x19, 0x1A]
));

/// `VSHNCTRL` (§8.2.13): source high negative voltage of the four source
/// voltage sets (see [`SourceVoltageSelect`]).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SourceHighNegativeVoltageControl {
    vshna: [SourceHighNegativeVoltage; 4],
}

impl SourceHighNegativeVoltageControl {
    /// Register default: -3.9 V in all four sets.
    pub const DEFAULT: Self = Self {
        vshna: [
            SourceHighNegativeVoltage::from_mv(-3_900),
            SourceHighNegativeVoltage::from_mv(-3_900),
            SourceHighNegativeVoltage::from_mv(-3_900),
            SourceHighNegativeVoltage::from_mv(-3_900),
        ],
    };

    /// `VSHNA1..=4`.
    #[must_use]
    pub const fn with_vshna(mut self, v: [SourceHighNegativeVoltage; 4]) -> Self {
        self.vshna = v;
        self
    }

    const fn bytes(&self) -> [u8; 4] {
        [
            self.vshna[0].0,
            self.vshna[1].0,
            self.vshna[2].0,
            self.vshna[3].0,
        ]
    }
}

impl Default for SourceHighNegativeVoltageControl {
    fn default() -> Self {
        Self::DEFAULT
    }
}

impl WriteCommand for SourceHighNegativeVoltageControl {
    const OPCODE: Instr = Instr::VSHNCTRL;
    type Params = [u8; 4];
    fn params(&self) -> Self::Params {
        self.bytes()
    }
}

millivolt_value!(
    /// Source high negative voltage VSHNAx.
    SourceHighNegativeVoltage: -5_200..=-2_500, zero = -2_500, step = 20
);

const _: () = assert!(matches!(
    SourceHighNegativeVoltageControl::DEFAULT.bytes(),
    [0x46, 0x46, 0x46, 0x46]
));
const _: () = assert!(matches!(
    SourceHighNegativeVoltageControl {
        vshna: [
            SourceHighNegativeVoltage::from_mv(-2_500),
            SourceHighNegativeVoltage::from_mv(-5_200),
            SourceHighNegativeVoltage::from_mv(-4_000),
            SourceHighNegativeVoltage::from_mv(-4_020),
        ]
    }
    .bytes(),
    [0x00, 0x87, 0x4B, 0x4C]
));

/// `VSLNCTRL` (§8.2.14): source low negative voltage of the four source
/// voltage sets (see [`SourceVoltageSelect`]).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SourceLowNegativeVoltageControl {
    vslna: [SourceLowNegativeVoltage; 4],
}

impl SourceLowNegativeVoltageControl {
    /// Register default: -0.4 V in all four sets.
    pub const DEFAULT: Self = Self {
        vslna: [
            SourceLowNegativeVoltage::from_mv(-400),
            SourceLowNegativeVoltage::from_mv(-400),
            SourceLowNegativeVoltage::from_mv(-400),
            SourceLowNegativeVoltage::from_mv(-400),
        ],
    };

    /// `VSLNA1..=4`.
    #[must_use]
    pub const fn with_vslna(mut self, v: [SourceLowNegativeVoltage; 4]) -> Self {
        self.vslna = v;
        self
    }

    const fn bytes(&self) -> [u8; 4] {
        [
            self.vslna[0].0,
            self.vslna[1].0,
            self.vslna[2].0,
            self.vslna[3].0,
        ]
    }
}

impl Default for SourceLowNegativeVoltageControl {
    fn default() -> Self {
        Self::DEFAULT
    }
}

impl WriteCommand for SourceLowNegativeVoltageControl {
    const OPCODE: Instr = Instr::VSLNCTRL;
    type Params = [u8; 4];
    fn params(&self) -> Self::Params {
        self.bytes()
    }
}

millivolt_value!(
    /// Source low negative voltage VSLNAx.
    SourceLowNegativeVoltage: -1_800..=1_000, zero = 1_000, step = 20
);

const _: () = assert!(matches!(
    SourceLowNegativeVoltageControl::DEFAULT.bytes(),
    [0x46, 0x46, 0x46, 0x46]
));
const _: () = assert!(matches!(
    SourceLowNegativeVoltageControl {
        vslna: [
            SourceLowNegativeVoltage::from_mv(1_000),
            SourceLowNegativeVoltage::from_mv(-1_800),
            SourceLowNegativeVoltage::from_mv(500),
            SourceLowNegativeVoltage::from_mv(480),
        ]
    }
    .bytes(),
    [0x00, 0x8C, 0x19, 0x1A]
));

/// `VSIKCTRL` (§8.2.15): source gamma voltages.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SourceGammaVoltageControl {
    vsip: VsipVoltage,
    vskp: VskpVoltage,
    vsin: VsinVoltage,
    vskn: VsknVoltage,
}

impl SourceGammaVoltageControl {
    /// Register default: VSIP 3.6 V, VSKP 2.6 V, VSIN -2.4 V, VSKN -1.4 V.
    pub const DEFAULT: Self = Self {
        vsip: VsipVoltage::from_mv(3_600),
        vskp: VskpVoltage::from_mv(2_600),
        vsin: VsinVoltage::from_mv(-2_400),
        vskn: VsknVoltage::from_mv(-1_400),
    };

    /// `VSIP[7:0]`: positive gamma voltage 1.
    #[must_use]
    pub const fn with_vsip(mut self, v: VsipVoltage) -> Self {
        self.vsip = v;
        self
    }

    /// `VSKP[7:0]`: positive gamma voltage 2.
    #[must_use]
    pub const fn with_vskp(mut self, v: VskpVoltage) -> Self {
        self.vskp = v;
        self
    }

    /// `VSIN[7:0]`: negative gamma voltage 1.
    #[must_use]
    pub const fn with_vsin(mut self, v: VsinVoltage) -> Self {
        self.vsin = v;
        self
    }

    /// `VSKN[7:0]`: negative gamma voltage 2.
    #[must_use]
    pub const fn with_vskn(mut self, v: VsknVoltage) -> Self {
        self.vskn = v;
        self
    }

    const fn bytes(&self) -> [u8; 4] {
        [self.vsip.0, self.vskp.0, self.vsin.0, self.vskn.0]
    }
}

impl Default for SourceGammaVoltageControl {
    fn default() -> Self {
        Self::DEFAULT
    }
}

impl WriteCommand for SourceGammaVoltageControl {
    const OPCODE: Instr = Instr::VSIKCTRL;
    type Params = [u8; 4];
    fn params(&self) -> Self::Params {
        self.bytes()
    }
}

millivolt_value!(
    /// Positive gamma voltage 1 (VSIP).
    VsipVoltage: 2_200..=5_000, zero = 2_200, step = 20
);
millivolt_value!(
    /// Positive gamma voltage 2 (VSKP).
    VskpVoltage: 1_200..=4_000, zero = 1_200, step = 20
);
millivolt_value!(
    /// Negative gamma voltage 1 (VSIN).
    VsinVoltage: -3_800..=-1_000, zero = -1_000, step = 20
);
millivolt_value!(
    /// Negative gamma voltage 2 (VSKN).
    VsknVoltage: -2_800..=0, zero = 0, step = 20
);

const _: () = assert!(matches!(
    SourceGammaVoltageControl::DEFAULT.bytes(),
    [0x46, 0x46, 0x46, 0x46]
));
const _: () = assert!(matches!(
    SourceGammaVoltageControl {
        vsip: VsipVoltage::from_mv(2_200),
        vskp: VskpVoltage::from_mv(1_200),
        vsin: VsinVoltage::from_mv(-1_000),
        vskn: VsknVoltage::from_mv(0),
    }
    .bytes(),
    [0x00, 0x00, 0x00, 0x00]
));
const _: () = assert!(matches!(
    SourceGammaVoltageControl::DEFAULT
        .with_vsip(VsipVoltage::from_mv(5_000))
        .with_vskp(VskpVoltage::from_mv(4_000))
        .with_vsin(VsinVoltage::from_mv(-3_800))
        .with_vskn(VsknVoltage::from_mv(-2_800))
        .bytes(),
    [0x8C, 0x8C, 0x8C, 0x8C]
));

/// `VSHLSEL` (§8.2.16): which of the four source voltage sets is used.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SourceVoltageSelect {
    sdhlsel: SourceVoltage,
}

impl SourceVoltageSelect {
    /// Register default: set 1.
    pub const DEFAULT: Self = Self {
        sdhlsel: SourceVoltage::Source1,
    };

    /// Uses the set `sdhlsel`.
    pub const fn new(sdhlsel: SourceVoltage) -> Self {
        Self { sdhlsel }
    }

    const fn bytes(&self) -> [u8; 1] {
        [self.sdhlsel as u8]
    }
}

impl Default for SourceVoltageSelect {
    fn default() -> Self {
        Self::DEFAULT
    }
}

impl WriteCommand for SourceVoltageSelect {
    const OPCODE: Instr = Instr::VSHLSEL;
    type Params = [u8; 1];
    fn params(&self) -> Self::Params {
        self.bytes()
    }
}

/// `VSHLSEL[1:0]`: a source voltage set.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SourceVoltage {
    /// VSHPA1/VSLPA1/VSHNA1/VSLNA1
    Source1 = 0,
    /// VSHPA2/VSLPA2/VSHNA2/VSLNA2
    Source2 = 1,
    /// VSHPA3/VSLPA3/VSHNA3/VSLNA3
    Source3 = 2,
    /// VSHPA4/VSLPA4/VSHNA4/VSLNA4
    Source4 = 3,
}

const _: () = assert!(matches!(SourceVoltageSelect::DEFAULT.bytes(), [0x00]));

/// `AUTOPWRCTRL` (§8.2.20): automatic power down on or off.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct AutoPowerDownControl {
    autopwr: AutoPowerDown,
}

impl AutoPowerDownControl {
    /// Register default `0xFF`: enabled.
    pub const DEFAULT: Self = Self {
        autopwr: AutoPowerDown::Enable,
    };

    /// `AUTOPWR` (D7) = `autopwr`.
    pub const fn new(autopwr: AutoPowerDown) -> Self {
        Self { autopwr }
    }

    #[allow(clippy::identity_op, reason = "readability")]
    const fn bytes(&self) -> [u8; 1] {
        [0xFF & !(1 << 7) | (self.autopwr as u8) << 7]
    }
}

impl Default for AutoPowerDownControl {
    fn default() -> Self {
        Self::DEFAULT
    }
}

impl WriteCommand for AutoPowerDownControl {
    const OPCODE: Instr = Instr::AUTOPWRCTRL;
    type Params = [u8; 1];
    fn params(&self) -> Self::Params {
        self.bytes()
    }
}

/// `AUTOPWR`: automatic power down.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AutoPowerDown {
    /// Off
    Disable = 0,
    /// On
    Enable = 1,
}

const _: () = assert!(matches!(AutoPowerDownControl::DEFAULT.bytes(), [0xFF]));

/// `BSTEN` (§8.2.21): booster on or off.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct BoosterControl {
    bsten: Booster,
}

impl BoosterControl {
    /// Register default `0x00`: booster off.
    pub const DEFAULT: Self = Self {
        bsten: Booster::Disable,
    };

    /// `BSTEN` (D0) = `bsten`.
    pub const fn new(bsten: Booster) -> Self {
        Self { bsten }
    }

    const fn bytes(&self) -> [u8; 1] {
        [self.bsten as u8]
    }
}

impl Default for BoosterControl {
    fn default() -> Self {
        Self::DEFAULT
    }
}

impl WriteCommand for BoosterControl {
    const OPCODE: Instr = Instr::BSTEN;
    type Params = [u8; 1];
    fn params(&self) -> Self::Params {
        self.bytes()
    }
}

/// `BSTEN`: booster.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Booster {
    /// Off
    Disable = 0,
    /// On
    Enable = 1,
}

const _: () = assert!(matches!(BoosterControl::DEFAULT.bytes(), [0x00]));

/// `OSCSET` (§8.2.23): oscillator on/off and the maximum HPM frame rate.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct OscSetting {
    oscen: OscEnable,
    oscsw: OscSwitch,
}

impl OscSetting {
    /// Register default `0x26, 0xE9`: oscillator off, 32 Hz maximum.
    pub const DEFAULT: Self = Self {
        oscen: OscEnable::Disable,
        oscsw: OscSwitch::HpmMax32Hz,
    };

    /// `OSCEN` (D7).
    #[must_use]
    pub const fn with_osc_en(mut self, v: OscEnable) -> Self {
        self.oscen = v;
        self
    }

    /// `OSCSW[2:0]` (D5, D2, D1).
    #[must_use]
    pub const fn with_osc_switch(mut self, v: OscSwitch) -> Self {
        self.oscsw = v;
        self
    }

    #[allow(clippy::identity_op, reason = "readability")]
    const fn bytes(&self) -> [u8; 2] {
        let sw = match self.oscsw {
            OscSwitch::HpmMax32Hz => 1 << 5 | 1 << 2 | 1 << 1,
            OscSwitch::HpmMax51Hz => 0,
        };
        [
            0x26 & !(1 << 7 | 1 << 5 | 0b11 << 1) | (self.oscen as u8) << 7 | sw,
            0xE9,
        ]
    }
}

impl Default for OscSetting {
    fn default() -> Self {
        Self::DEFAULT
    }
}

impl WriteCommand for OscSetting {
    const OPCODE: Instr = Instr::OSCSET;
    type Params = [u8; 2];
    fn params(&self) -> Self::Params {
        self.bytes()
    }
}

/// `OSCEN`: oscillator.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum OscEnable {
    /// Off
    Disable = 0,
    /// On
    Enable = 1,
}

/// OSCSW\[2:0\]: selects the maximum HPM frame rate.
/// The actual rate is this maximum at HFRA=1 and half of it at HFRA=0 (see FRCTRL).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum OscSwitch {
    /// OSCSW = 000
    HpmMax51Hz = 0b000,
    /// OSCSW = 111
    HpmMax32Hz = 0b111,
}

const _: () = assert!(matches!(OscSetting::DEFAULT.bytes(), [0x26, 0xE9]));