diff --git a/adi/ltc2672.py b/adi/ltc2672.py index 55cc8c9d58..fab386e9f3 100644 --- a/adi/ltc2672.py +++ b/adi/ltc2672.py @@ -2,8 +2,6 @@ # # SPDX short identifier: ADIBSD -from decimal import Decimal - from adi.attribute import attribute from adi.context_manager import context_manager @@ -18,7 +16,7 @@ def __init__(self, uri="", device_name=""): """Constructor for LTC2672 class""" context_manager.__init__(self, uri, self._device_name) - compatible_parts = ["ltc2672-16", "ltc2672-12"] + compatible_parts = ["ltc2672-16", "ltc2672-12", "ltc2662-16", "ltc2662-12"] self._ctrl = None self.channel = [] @@ -47,6 +45,16 @@ def __init__(self, uri="", device_name=""): self.output_bits.append(ch.data_format.bits) self.channel.append(self._channel(self._ctrl, name)) + @property + def sampling_frequency(self): + """Get sampling frequency value""" + return self._get_iio_dev_attr_str("sampling_frequency") + + @sampling_frequency.setter + def sampling_frequency(self, value): + """Get sampling frequency value""" + self._set_iio_dev_attr_str("sampling_frequency", value) + @property def all_chns_span(self): """Get all channels span in mA""" @@ -65,7 +73,7 @@ def all_chns_span(self, value): else: raise ValueError( "Error: span setting not supported \nUse one of: " - "str(self.all_chns_span_avail)" + + str(self.all_chns_span_avail) ) @property @@ -79,34 +87,34 @@ def all_chns_raw(self, value): self._set_iio_dev_attr_str("all_chns_raw", value) @property - def all_chns_current(self): - """Get current value in mA""" - return self._get_iio_dev_attr_str("all_chns_current") + def all_chns_input_register_and_update(self): + """Get input register and update value in mA""" + return self._get_iio_dev_attr_str("all_chns_input_register_and_update") - @all_chns_current.setter - def all_chns_current(self, value): - """Set current value in mA""" - self._set_iio_dev_attr_str("all_chns_current", value) + @all_chns_input_register_and_update.setter + def all_chns_input_register_and_update(self, value): + """Set input register and update value in mA""" + self._set_iio_dev_attr_str("all_chns_input_register_and_update", value) @property - def all_chns_powerdown(self): + def powerdown_chip(self): """Get powerdown value""" - return self._get_iio_dev_attr_str("all_chns_powerdown") + return self._get_iio_dev_attr_str("powerdown_chip") @property - def all_chns_powerdown_avail(self): + def powerdown_chip_avail(self): """Get powerdown options""" - return self._get_iio_dev_attr_str("all_chns_powerdown_available") + return self._get_iio_dev_attr_str("powerdown_chip_available") - @all_chns_powerdown.setter - def all_chns_powerdown(self, value): - """Set all channels powerdown""" - if value in self.all_chns_powerdown_avail: - self._set_iio_dev_attr_str("all_chns_powerdown", value) + @powerdown_chip.setter + def powerdown_chip(self, value): + """Powerdown the chip""" + if value in self.powerdown_chip_avail: + self._set_iio_dev_attr_str("powerdown_chip", value) else: raise ValueError( "Error: powerdown option not supported \nUse one of: " - "str(self.all_chns_powerdown_avail)" + + str(self.powerdown_chip_avail) ) @property @@ -121,23 +129,298 @@ def mux_avail(self): @mux.setter def mux(self, value): - """Set mux option""" + """Set mux value""" if value in self.mux_avail: self._set_iio_dev_attr_str("mux", value) else: raise ValueError( - "Error: mux setting not supported \nUse one of: " "str(self.mux_avail)" + "Error: mux setting not supported \nUse one of: " + str(self.mux_avail) + ) + + @property + def readback(self): + """Get readback value""" + return self._get_iio_dev_attr_str("readback") + + @property + def reset(self): + """Get reset value""" + return self._get_iio_dev_attr_str("reset") + + @property + def reset_avail(self): + """Get reset options""" + return self._get_iio_dev_attr_str("reset_available") + + @reset.setter + def reset(self, value): + """Reset the device using CLR pin""" + if value in self.reset_avail: + self._set_iio_dev_attr_str("reset", value) + else: + raise ValueError( + "Error: reset option not supported \nUse one of: " + + str(self.reset_avail) + ) + + @property + def toggle_pin_state(self): + """Get toggle pin state""" + return self._get_iio_dev_attr_str("toggle_pin_state") + + @property + def toggle_pin_state_avail(self): + """Get toggle pin state options""" + return self._get_iio_dev_attr_str("toggle_pin_state_available") + + @toggle_pin_state.setter + def toggle_pin_state(self, value): + """Set toggle pin state""" + if value in self.toggle_pin_state_avail: + self._set_iio_dev_attr_str("toggle_pin_state", value) + else: + raise ValueError( + "Error: toggle pin state option not supported \nUse one of: " + + str(self.toggle_pin_state_avail) + ) + + @property + def toggle_pwm(self): + """Get toggle PWM value""" + return self._get_iio_dev_attr_str("toggle_pwm") + + @property + def toggle_pwm_avail(self): + """Get toggle PWM options""" + return self._get_iio_dev_attr_str("toggle_pwm_available") + + @toggle_pwm.setter + def toggle_pwm(self, value): + """Configure toggle PWM""" + if value in self.toggle_pwm_avail: + self._set_iio_dev_attr_str("toggle_pwm", value) + else: + raise ValueError( + "Error: toggle PWM option not supported \nUse one of: " + + str(self.toggle_pwm_avail) + ) + + @property + def all_chns_input_register_a(self): + """Get input register A value in mA""" + return self._get_iio_dev_attr_str("all_chns_input_register_a") + + @all_chns_input_register_a.setter + def all_chns_input_register_a(self, value): + """Set input register A value""" + self._set_iio_dev_attr_str("all_chns_input_register_a", value) + + @property + def all_chns_input_register_b(self): + """Get input register B value in mA""" + return self._get_iio_dev_attr_str("all_chns_input_register_b") + + @all_chns_input_register_b.setter + def all_chns_input_register_b(self, value): + """Set input register B value""" + self._set_iio_dev_attr_str("all_chns_input_register_b", value) + + @property + def hw_ldac_update(self): + """Get HW LDAC update value""" + return self._get_iio_dev_attr_str("hw_ldac_update") + + @property + def hw_ldac_update_avail(self): + """Get HW LDAC update options""" + return self._get_iio_dev_attr_str("hw_ldac_update_available") + + @hw_ldac_update.setter + def hw_ldac_update(self, value): + """Update using the LDAC pin""" + if value in self.hw_ldac_update_avail: + self._set_iio_dev_attr_str("hw_ldac_update", value) + else: + raise ValueError( + "Error: update option not supported \nUse one of: " + + str(self.hw_ldac_update_avail) + ) + + @property + def all_chns_sw_update(self): + """Get SW update value""" + return self._get_iio_dev_attr_str("all_chns_sw_update") + + @property + def all_chns_sw_update_avail(self): + """Get SW update options""" + return self._get_iio_dev_attr_str("all_chns_sw_update_available") + + @all_chns_sw_update.setter + def all_chns_sw_update(self, value): + """Update using the SW command""" + if value in self.all_chns_sw_update_avail: + self._set_iio_dev_attr_str("all_chns_sw_update", value) + else: + raise ValueError( + "Error: update option not supported \nUse one of: " + + str(self.all_chns_sw_update_avail) + ) + + @property + def fault_alert(self): + """Get fault alert value""" + return self._get_iio_dev_attr_str("fault_alert") + + @property + def fault_alert_avail(self): + """Get fault alert options""" + return self._get_iio_dev_attr_str("fault_alert_available") + + @property + def open_circuit_detection(self): + """Get open circuit detection value""" + return self._get_iio_dev_attr_str("open_circuit_detection") + + @property + def open_circuit_detection_avail(self): + """Get open circuit detection options""" + return self._get_iio_dev_attr_str("open_circuit_detection_available") + + @open_circuit_detection.setter + def open_circuit_detection(self, value): + """Configure open circuit detection""" + if value in self.open_circuit_detection_avail: + self._set_iio_dev_attr_str("open_circuit_detection", value) + else: + raise ValueError( + "Error: open circuit detection option not supported \nUse one of: " + + str(self.open_circuit_detection_avail) + ) + + @property + def thermal_shutdown_protection(self): + """Get thermal shutdown protection value""" + return self._get_iio_dev_attr_str("thermal_shutdown_protection") + + @property + def thermal_shutdown_protection_avail(self): + """Get thermal shutdown protection options""" + return self._get_iio_dev_attr_str("thermal_shutdown_protection_available") + + @thermal_shutdown_protection.setter + def thermal_shutdown_protection(self, value): + """Configure thermal shutdown protection""" + if value in self.thermal_shutdown_protection_avail: + self._set_iio_dev_attr_str("thermal_shutdown_protection", value) + else: + raise ValueError( + "Error: thermal shutdown protection option not supported \nUse one of: " + + str(self.thermal_shutdown_protection_avail) + ) + + @property + def external_reference(self): + """Get external reference value""" + return self._get_iio_dev_attr_str("external_reference") + + @property + def external_reference_avail(self): + """Get external reference options""" + return self._get_iio_dev_attr_str("external_reference_available") + + @external_reference.setter + def external_reference(self, value): + """Configure external reference""" + if value in self.external_reference_avail: + self._set_iio_dev_attr_str("external_reference", value) + else: + raise ValueError( + "Error: external reference option not supported \nUse one of: " + + str(self.external_reference_avail) + ) + + @property + def sw_toggle_state(self): + """Get software toggle state""" + return self._get_iio_dev_attr_str("sw_toggle_state") + + @property + def sw_toggle_state_avail(self): + """Get software toggle state options""" + return self._get_iio_dev_attr_str("sw_toggle_state_available") + + @sw_toggle_state.setter + def sw_toggle_state(self, value): + """Configure software toggle state""" + if value in self.sw_toggle_state_avail: + self._set_iio_dev_attr_str("sw_toggle_state", value) + else: + raise ValueError( + "Error: software toggle state option not supported \nUse one of: " + + str(self.sw_toggle_state_avail) ) @property - def fault_detect(self): - """Get fault condition if any""" - return self._get_iio_dev_attr_str("fault_detect") + def over_temperature_fault(self): + """Get over temperature fault value""" + return self._get_iio_dev_attr_str("over_temperature_fault") @property - def fault_detect_avail(self): - """Get fault detect options""" - return self._get_iio_dev_attr_str("fault_detect_available") + def over_temperature_fault_avail(self): + """Get over temperature fault options""" + return self._get_iio_dev_attr_str("over_temperature_fault_available") + + @property + def invalid_spi_seq_length(self): + """Get invalid SPI sequence length value""" + return self._get_iio_dev_attr_str("invalid_spi_seq_length") + + @property + def invalid_spi_seq_length_avail(self): + """Get invalid SPI sequence length options""" + return self._get_iio_dev_attr_str("invalid_spi_seq_length_available") + + @property + def reference_in_volts(self): + """Get reference value in volts""" + return self._get_iio_dev_attr_str("reference_in_volts") + + @reference_in_volts.setter + def reference_in_volts(self, value): + """Set reference value in volts""" + self._set_iio_dev_attr_str("reference_in_volts", value) + + @property + def fsadj_res_in_kohm(self): + """Get FSADJ resistor value in k-ohm""" + return self._get_iio_dev_attr_str("fsadj_res_in_kohm") + + @fsadj_res_in_kohm.setter + def fsadj_res_in_kohm(self, value): + """Set FSADJ resistor value in k-ohm""" + self._set_iio_dev_attr_str("fsadj_res_in_kohm", value) + + @property + def no_op_cmd(self): + """Get no operation command value""" + return self._get_iio_dev_attr_str("no_op_cmd") + + @property + def no_op_cmd_avail(self): + """Get no operation command options""" + return self._get_iio_dev_attr_str("no_op_cmd_available") + + @no_op_cmd.setter + def no_op_cmd(self, value): + """Send no operation command""" + if value in self.no_op_cmd_avail: + self._set_iio_dev_attr_str("no_op_cmd", value) + else: + raise ValueError( + "Error: command option not supported \nUse one of: " + + str(self.no_op_cmd_avail) + ) class _channel(attribute): """LTC2672 channel""" @@ -167,14 +450,14 @@ def offset(self): return self._get_iio_attr(self.name, "offset", True) @property - def current(self): - """Get channel current value in mA""" - return self._get_iio_attr(self.name, "current", True) + def input_register_and_update(self): + """Get channel value of input and update in mA""" + return self._get_iio_attr(self.name, "input_register_and_update", True) - @current.setter - def current(self, value): - """Set channel current value in mA""" - self._set_iio_attr(self.name, "current", True, str(Decimal(value))) + @input_register_and_update.setter + def input_register_and_update(self, value): + """Set channel value of input and update in mA""" + self._set_iio_attr(self.name, "input_register_and_update", True, value) @property def span(self): @@ -194,7 +477,7 @@ def span(self, value): else: raise ValueError( "Error: span setting not supported \nUse one of: " - "str(self.span_avail)" + + str(self.span_avail) ) @property @@ -215,5 +498,93 @@ def powerdown(self, value): else: raise ValueError( "Error: powerdown setting not supported \nUse one of: " - "str(self.powerdown_avail)" + + str(self.powerdown_avail) + ) + + @property + def input_register_a(self): + """Get channel input register A value in mA""" + return self._get_iio_attr(self.name, "input_register_a", True) + + @input_register_a.setter + def input_register_a(self, value): + """Set channel input register A value""" + self._set_iio_attr(self.name, "input_register_a", True, value) + + @property + def input_register_b(self): + """Get channel input register B value in mA""" + return self._get_iio_attr(self.name, "input_register_b", True) + + @input_register_b.setter + def input_register_b(self, value): + """Set channel input register B value""" + self._set_iio_attr(self.name, "input_register_b", True, value) + + @property + def sw_update(self): + """Get channel SW update value""" + return self._get_iio_attr_str(self.name, "sw_update", True) + + @property + def sw_update_avail(self): + """Get channel SW update options""" + return self._get_iio_attr_str(self.name, "sw_update_available", True) + + @sw_update.setter + def sw_update(self, value): + """Update the channel using SW command""" + if value in self.sw_update_avail: + self._set_iio_attr(self.name, "sw_update", True, value) + else: + raise ValueError( + "Error: SW update option not supported \nUse one of: " + + str(self.sw_update_avail) ) + + @property + def input_register_and_update_all_chns(self): + """Set input register and update all channels value in mA""" + return self._get_iio_attr( + self.name, "input_register_and_update_all_chns", True + ) + + @input_register_and_update_all_chns.setter + def input_register_and_update_all_chns(self, value): + """Set input register and update all channels value""" + self._set_iio_attr( + self.name, "input_register_and_update_all_chns", True, value + ) + + @property + def toggle_select(self): + """Get channel toggle select value""" + return self._get_iio_attr_str(self.name, "toggle_select", True) + + @property + def toggle_select_avail(self): + """Get channel toggle select options""" + return self._get_iio_attr_str(self.name, "toggle_select_available", True) + + @toggle_select.setter + def toggle_select(self, value): + """Configure channel toggle select""" + if value in self.toggle_select_avail: + self._set_iio_attr(self.name, "toggle_select", True, value) + else: + raise ValueError( + "Error: channel toggle select option not supported \nUse one of: " + + str(self.toggle_select_avail) + ) + + @property + def open_circuit_fault(self): + """Get channel open circuit fault value""" + return self._get_iio_attr_str(self.name, "open_circuit_fault", True) + + @property + def open_circuit_fault_avail(self): + """Get channel open circuit fault options""" + return self._get_iio_attr_str( + self.name, "open_circuit_fault_available", True + ) diff --git a/examples/ltc2672_example.py b/examples/ltc2672_example.py index 4e8087506d..020c395f9c 100644 --- a/examples/ltc2672_example.py +++ b/examples/ltc2672_example.py @@ -34,7 +34,7 @@ from adi.ltc2672 import ltc2672 # Set up LTC2672 -ltc2672_dev = ltc2672(uri="serial:COM5,230400,8n1") +ltc2672_dev = ltc2672(uri="serial:COM34,230400,8n1", device_name="ltc2672-16") # Set all channels span to 50mA ltc2672_dev.all_chns_span = "50mA" @@ -45,14 +45,14 @@ ltc2672_chan.raw = 25000 # Get the current value of channel 0 in mA for the corresponding raw value set -current_val_ma = ltc2672_chan.current +current_val_ma = ltc2672_chan.input_register_and_update print(f"Channel{chn_num} current in mA: {current_val_ma}") # Set current value for channel 0 in mA -ltc2672_chan.current = 45 +ltc2672_chan.input_register_and_update = 45 # Set mux value to "iout0" to monitor iout0 value on the mux_out pin ltc2672_dev.mux = "iout0" # Powerdown all the channels of the DAC -ltc2672_dev.all_chns_powerdown = "powerdown" +ltc2672_dev.powerdown_chip = "powerdown" diff --git a/supported_parts.md b/supported_parts.md index 89b59332f6..53e74ff893 100644 --- a/supported_parts.md +++ b/supported_parts.md @@ -223,6 +223,8 @@ - LTC2380-16 - LTC2387-18 - LTC2499 +- LTC2662-12 +- LTC2662-16 - LTC2664 - LTC2688 - LTC2672-12 diff --git a/test/emu/devices/ltc2672.xml b/test/emu/devices/ltc2672.xml index 114dcc15fd..8e04e3ed91 100644 --- a/test/emu/devices/ltc2672.xml +++ b/test/emu/devices/ltc2672.xml @@ -1 +1 @@ -]> \ No newline at end of file +]> \ No newline at end of file diff --git a/test/test_ltc2672.py b/test/test_ltc2672.py index c744528827..3db9d4f1e6 100644 --- a/test/test_ltc2672.py +++ b/test/test_ltc2672.py @@ -28,7 +28,7 @@ "300mA", ], ), - ("all_chns_powerdown", ["powerdown"],), + ("powerdown_chip", ["powerdown"],), ], ) def test_ltc2672_global_attr(