From c83e78e4d8457fddaa7311882c56b3b6b40f9a82 Mon Sep 17 00:00:00 2001 From: Trisha De Vera Date: Fri, 15 Mar 2024 10:16:14 +0800 Subject: [PATCH] Add adis16480 support Signed-off-by: Trisha De Vera --- adi/__init__.py | 1 + adi/adis16480.py | 493 +++++++++++++++++++++++++++++++++ examples/adis16480_example.py | 47 ++++ supported_parts.md | 1 + test/emu/devices/adis16480.xml | 2 + test/emu/hardware_map.yml | 9 + test/test_adis16480.py | 81 ++++++ 7 files changed, 634 insertions(+) create mode 100644 adi/adis16480.py create mode 100644 examples/adis16480_example.py create mode 100644 test/emu/devices/adis16480.xml create mode 100644 test/test_adis16480.py diff --git a/adi/__init__.py b/adi/__init__.py index 3e0c53163..e80665d11 100644 --- a/adi/__init__.py +++ b/adi/__init__.py @@ -55,6 +55,7 @@ from adi.adg2128 import adg2128 from adi.adis16460 import adis16460 from adi.adis16475 import adis16475 +from adi.adis16480 import adis16480 from adi.adis16495 import adis16495 from adi.adis16507 import adis16507 from adi.adl5240 import adl5240 diff --git a/adi/adis16480.py b/adi/adis16480.py new file mode 100644 index 000000000..7d6b362f2 --- /dev/null +++ b/adi/adis16480.py @@ -0,0 +1,493 @@ +# Copyright (C) 2019-2024 Analog Devices, Inc. +# +# SPDX short identifier: ADIBSD + +import numpy as np +from adi.attribute import attribute +from adi.context_manager import context_manager +from adi.rx_tx import rx + + +class adis16480(rx, context_manager): + """ ADIS16480 Ten Degrees of Freedom Inertial Sensor with Dynamic Orientation Outputs """ + + _complex_data = False + _rx_channel_names = [ + "anglvel_x", + "anglvel_y", + "anglvel_z", + "accel_x", + "accel_y", + "accel_z", + "magn_x", + "magn_y", + "magn_z", + "pressure0", + "temp0", + ] + _device_name = "" + + def __init__(self, uri="", device_name="adis16480", trigger_name="adis16480-dev0"): + context_manager.__init__(self, uri, self._device_name) + + compatible_parts = [ + "adis16375", + "adis16480", + "adis16485", + "adis16488", + "adis16490", + "adis16495-1", + "adis16495-2", + "adis16495-3", + "adis16497-1", + "adis16497-2", + "adis16497-3", + ] + + if device_name not in compatible_parts: + raise Exception( + "Not a compatible device:" + + str(device_name) + + ".Please select from:" + + str(compatible_parts) + ) + else: + self._ctrl = self._ctx.find_device(device_name) + self._rxadc = self._ctx.find_device(device_name) + + if self._ctrl is None: + print( + "No device found with device_name = " + + device_name + + ". Searching for a device found in the compatible list." + ) + for i in compatible_parts: + self._ctrl = self._ctx.find_device(i) + self._rxadc = self._ctx.find_device(i) + if self._ctrl is not None: + print("Fond device = " + i + ". Will use this device instead.") + break + if self._ctrl is None: + raise Exception("No compatible device found") + + self.anglvel_x = self._anglvel_accel_channels(self._ctrl, "anglvel_x") + self.anglvel_y = self._anglvel_accel_channels(self._ctrl, "anglvel_y") + self.anglvel_z = self._anglvel_accel_channels(self._ctrl, "anglvel_z") + self.accel_x = self._anglvel_accel_channels(self._ctrl, "accel_x") + self.accel_y = self._anglvel_accel_channels(self._ctrl, "accel_y") + self.accel_z = self._anglvel_accel_channels(self._ctrl, "accel_z") + self.temp = self._temp_channel(self._ctrl, "temp0") + self.pressure = self._pressure_channel(self._ctrl, "pressure0") + self.magn_x = self._magn_channel(self._ctrl, "magn_x") + self.magn_y = self._magn_channel(self._ctrl, "magn_y") + self.magn_z = self._magn_channel(self._ctrl, "magn_z") + + # Set default trigger + self._trigger = self._ctx.find_device(trigger_name) + self._rxadc._set_trigger(self._trigger) + + rx.__init__(self) + self.rx_buffer_size = 16 # Make default buffer smaller + + def __get_scaled_sensor(self, channel_name: str) -> float: + raw = self._get_iio_attr(channel_name, "raw", False) + scale = self._get_iio_attr(channel_name, "scale", False) + + return raw * scale + + def __get_scaled_sensor_temp(self, channel_name: str) -> float: + raw = self._get_iio_attr(channel_name, "raw", False) + scale = self._get_iio_attr(channel_name, "scale", False) + offset = self._get_iio_attr(channel_name, "offset", False) + + return (raw + offset) * scale + + def get_anglvel_x(self): + """Value returned in radians per second.""" + return self.__get_scaled_sensor("anglvel_x") + + anglvel_x_conv = property(get_anglvel_x, None) + + def get_anglvel_y(self): + """Value returned in radians per second.""" + return self.__get_scaled_sensor("anglvel_y") + + anglvel_y_conv = property(get_anglvel_y, None) + + def get_anglvel_z(self): + """Value returned in radians per second.""" + return self.__get_scaled_sensor("anglvel_z") + + anglvel_z_conv = property(get_anglvel_z, None) + + def get_accel_x(self): + """Value returned in meters per squared second.""" + return self.__get_scaled_sensor("accel_x") + + accel_x_conv = property(get_accel_x, None) + + def get_accel_y(self): + """Value returned in meters per squared second.""" + return self.__get_scaled_sensor("accel_y") + + accel_y_conv = property(get_accel_y, None) + + def get_accel_z(self): + """Value returned in meters per squared second.""" + return self.__get_scaled_sensor("accel_z") + + accel_z_conv = property(get_accel_z, None) + + def get_magn_x(self): + """Value returned in radians.""" + return self.__get_scaled_sensor("magn_x") + + magn_x_conv = property(get_magn_x, None) + + def get_magn_y(self): + """Value returned in radians.""" + return self.__get_scaled_sensor("magn_y") + + magn_y_conv = property(get_magn_y, None) + + def get_magn_z(self): + """Value returned in radians.""" + return self.__get_scaled_sensor("magn_z") + + magn_z_conv = property(get_magn_z, None) + + def get_temp(self): + """Value returned in millidegrees Celsius.""" + return self.__get_scaled_sensor_temp("temp0") + + temp_conv = property(get_temp, None) + + def get_pressure(self): + """Value returned in kilo Pascal.""" + return self.__get_scaled_sensor("pressure0") + + pressure_conv = property(get_pressure, None) + + @property + def sample_rate(self): + """sample_rate: Sample rate in samples per second""" + return self._get_iio_dev_attr("sampling_frequency") + + @sample_rate.setter + def sample_rate(self, value): + self._set_iio_dev_attr_str("sampling_frequency", value) + + @property + def current_timestamp_clock(self): + """current_timestamp_clock: Source clock for timestamps""" + return self._get_iio_dev_attr("current_timestamp_clock") + + @current_timestamp_clock.setter + def current_timestamp_clock(self, value): + self._set_iio_dev_attr_str("current_timestamp_clock", value) + + @property + def anglvel_x_calibbias(self): + """User calibration offset for gyroscope for the x-axis.""" + return self._get_iio_attr("anglvel_x", "calibbias", False) + + @anglvel_x_calibbias.setter + def anglvel_x_calibbias(self, value): + self._set_iio_attr("anglvel_x", "calibbias", False, value) + + @property + def anglvel_y_calibbias(self): + """User calibration offset for gyroscope for the y-axis.""" + return self._get_iio_attr("anglvel_y", "calibbias", False) + + @anglvel_y_calibbias.setter + def anglvel_y_calibbias(self, value): + self._set_iio_attr("anglvel_y", "calibbias", False, value) + + @property + def anglvel_z_calibbias(self): + """User calibration offset for gyroscope for the z-axis.""" + return self._get_iio_attr("anglvel_z", "calibbias", False) + + @anglvel_z_calibbias.setter + def anglvel_z_calibbias(self, value): + self._set_iio_attr("anglvel_z", "calibbias", False, value) + + @property + def accel_x_calibbias(self): + """User calibration offset for accelerometer for the x-axis.""" + return self._get_iio_attr("accel_x", "calibbias", False) + + @accel_x_calibbias.setter + def accel_x_calibbias(self, value): + self._set_iio_attr("accel_x", "calibbias", False, value) + + @property + def accel_y_calibbias(self): + """User calibration offset for accelerometer for the y-axis.""" + return self._get_iio_attr("accel_y", "calibbias", False) + + @accel_y_calibbias.setter + def accel_y_calibbias(self, value): + self._set_iio_attr("accel_y", "calibbias", False, value) + + @property + def accel_z_calibbias(self): + """User calibration offset for accelerometer for the z-axis.""" + return self._get_iio_attr("accel_z", "calibbias", False) + + @accel_z_calibbias.setter + def accel_z_calibbias(self, value): + self._set_iio_attr("accel_z", "calibbias", False, value) + + @property + def magn_x_calibbias(self): + """User calibration offset for magnetometer for the x-axis.""" + return self._get_iio_attr("magn_x", "calibbias", False) + + @magn_x_calibbias.setter + def magn_x_calibbias(self, value): + self._set_iio_attr("magn_x", "calibbias", False, value) + + @property + def magn_y_calibbias(self): + """User calibration offset for magnetometer for the y-axis.""" + return self._get_iio_attr("magn_y", "calibbias", False) + + @magn_y_calibbias.setter + def magn_y_calibbias(self, value): + self._set_iio_attr("magn_y", "calibbias", False, value) + + @property + def magn_z_calibbias(self): + """User calibration offset for magnetometer for the z-axis.""" + return self._get_iio_attr("magn_z", "calibbias", False) + + @magn_z_calibbias.setter + def magn_z_calibbias(self, value): + self._set_iio_attr("magn_z", "calibbias", False, value) + + @property + def pressure_calibbias(self): + """User calibration offset for pressure.""" + return self._get_iio_attr("pressure0", "calibbias", False) + + @pressure_calibbias.setter + def pressure_calibbias(self, value): + self._set_iio_attr("pressure0", "calibbias", False, value) + + ##### + @property + def anglvel_x_calibscale(self): + """Calibscale value for gyroscope for the x-axis.""" + return self._get_iio_attr("anglvel_x", "calibscale", False) + + @anglvel_x_calibscale.setter + def anglvel_x_calibscale(self, value): + self._set_iio_attr("anglvel_x", "calibscale", False, value) + + @property + def anglvel_y_calibscale(self): + """Calibscale value for gyroscope for the y-axis.""" + return self._get_iio_attr("anglvel_y", "calibscale", False) + + @anglvel_y_calibscale.setter + def anglvel_y_calibscale(self, value): + self._set_iio_attr("anglvel_y", "calibscale", False, value) + + @property + def anglvel_z_calibscale(self): + """Calibscale value for gyroscope for the z-axis.""" + return self._get_iio_attr("anglvel_z", "calibscale", False) + + @anglvel_z_calibscale.setter + def anglvel_z_calibscale(self, value): + self._set_iio_attr("anglvel_z", "calibscale", False, value) + + @property + def accel_x_calibscale(self): + """Calibscale value for accelerometer for the x-axis.""" + return self._get_iio_attr("accel_x", "calibscale", False) + + @accel_x_calibscale.setter + def accel_x_calibscale(self, value): + self._set_iio_attr("accel_x", "calibscale", False, value) + + @property + def accel_y_calibscale(self): + """Calibcale value for accelerometer for the y-axis.""" + return self._get_iio_attr("accel_y", "calibscale", False) + + @accel_y_calibscale.setter + def accel_y_calibscale(self, value): + self._set_iio_attr("accel_y", "calibscale", False, value) + + @property + def accel_z_calibscale(self): + """Calibscale for accelerometer for the z-axis.""" + return self._get_iio_attr("accel_z", "calibscale", False) + + @accel_z_calibscale.setter + def accel_z_calibscale(self, value): + self._set_iio_attr("accel_z", "calibscale", False, value) + + @property + def anglvel_x_filter_low_pass_3db_frequency(self): + """Bandwidth for gyroscope for the x-axis.""" + return self._get_iio_attr("anglvel_x", "filter_low_pass_3db_frequency", False) + + @anglvel_x_filter_low_pass_3db_frequency.setter + def anglvel_x_filter_low_pass_3db_frequency(self, value): + self._set_iio_attr("anglvel_x", "filter_low_pass_3db_frequency", False, value) + + @property + def anglvel_y_filter_low_pass_3db_frequency(self): + """Bandwidth for gyroscope for the y-axis.""" + return self._get_iio_attr("anglvel_y", "filter_low_pass_3db_frequency", False) + + @anglvel_y_filter_low_pass_3db_frequency.setter + def anglvel_y_filter_low_pass_3db_frequency(self, value): + self._set_iio_attr("anglvel_y", "filter_low_pass_3db_frequency", False, value) + + @property + def anglvel_z_filter_low_pass_3db_frequency(self): + """Bandwidth for gyroscope for the z-axis.""" + return self._get_iio_attr("anglvel_z", "filter_low_pass_3db_frequency", False) + + @anglvel_z_filter_low_pass_3db_frequency.setter + def anglvel_z_filter_low_pass_3db_frequency(self, value): + self._set_iio_attr("anglvel_z", "filter_low_pass_3db_frequency", False, value) + + @property + def accel_x_filter_low_pass_3db_frequency(self): + """Bandwidth for accelerometer for the x-axis.""" + return self._get_iio_attr("accel_x", "filter_low_pass_3db_frequency", False) + + @accel_x_filter_low_pass_3db_frequency.setter + def accel_x_filter_low_pass_3db_frequency(self, value): + self._set_iio_attr("accel_x", "filter_low_pass_3db_frequency", False, value) + + @property + def accel_y_filter_low_pass_3db_frequency(self): + """Bandwidth for accelerometer for the y-axis.""" + return self._get_iio_attr("accel_y", "filter_low_pass_3db_frequency", False) + + @accel_y_filter_low_pass_3db_frequency.setter + def accel_y_filter_low_pass_3db_frequency(self, value): + self._set_iio_attr("accel_y", "filter_low_pass_3db_frequency", False, value) + + @property + def accel_z_filter_low_pass_3db_frequency(self): + """Bandwidth for accelerometer for the z-axis.""" + return self._get_iio_attr("accel_z", "filter_low_pass_3db_frequency", False) + + @accel_z_filter_low_pass_3db_frequency.setter + def accel_z_filter_low_pass_3db_frequency(self, value): + self._set_iio_attr("accel_z", "filter_low_pass_3db_frequency", False, value) + + @property + def magn_x_filter_low_pass_3db_frequency(self): + """Bandwidth for magnetometer for the x-axis.""" + return self._get_iio_attr("magn_x", "filter_low_pass_3db_frequency", False) + + @magn_x_filter_low_pass_3db_frequency.setter + def magn_x_filter_low_pass_3db_frequency(self, value): + self._set_iio_attr("magn_x", "filter_low_pass_3db_frequency", False, value) + + @property + def magn_y_filter_low_pass_3db_frequency(self): + """Bandwidth for magnetometer for the y-axis.""" + return self._get_iio_attr("magn_y", "filter_low_pass_3db_frequency", False) + + @magn_y_filter_low_pass_3db_frequency.setter + def magn_y_filter_low_pass_3db_frequency(self, value): + self._set_iio_attr("magn_y", "filter_low_pass_3db_frequency", False, value) + + @property + def magn_z_filter_low_pass_3db_frequency(self): + """Bandwidth for magnetometer for the z-axis.""" + return self._get_iio_attr("magn_z", "filter_low_pass_3db_frequency", False) + + @magn_z_filter_low_pass_3db_frequency.setter + def magn_z_filter_low_pass_3db_frequency(self, value): + self._set_iio_attr("magn_z", "filter_low_pass_3db_frequency", False, value) + + class _temp_channel(attribute): + """ADIS16480 temperature channel.""" + + def __init__(self, ctrl, channel_name): + self.name = channel_name + self._ctrl = ctrl + + @property + def raw(self): + """ADIS16480 raw value""" + return self._get_iio_attr(self.name, "raw", False) + + @property + def scale(self): + """ADIS16480 scale value""" + return self._get_iio_attr(self.name, "scale", False) + + @property + def offset(self): + """ADIS16480 offset value""" + return self._get_iio_attr(self.name, "offset", False) + + class _pressure_channel(attribute): + """ADIS16480 pressure channel.""" + + def __init__(self, ctrl, channel_name): + self.name = channel_name + self._ctrl = ctrl + + @property + def raw(self): + """ADIS16480 raw value""" + return self._get_iio_attr(self.name, "raw", False) + + @property + def scale(self): + """ADIS16480 scale value""" + return self._get_iio_attr(self.name, "scale", False) + + @property + def calibbias(self): + """ADIS16480 calibration offset""" + return self._get_iio_attr(self.name, "calibbias", False) + + @calibbias.setter + def calibbias(self, value): + self._set_iio_attr(self.name, "calibbias", False, value) + + class _magn_channel(_pressure_channel): + """ADIS16480 magnetometer channel.""" + + def __init__(self, ctrl, channel_name): + self.name = channel_name + self._ctrl = ctrl + + @property + def filter_low_pass_3db_frequency(self): + """ADIS16480 channel bandwidth""" + return self._get_iio_attr(self.name, "filter_low_pass_3db_frequency", False) + + @filter_low_pass_3db_frequency.setter + def filter_low_pass_3db_frequency(self, value): + self._set_iio_attr(self.name, "filter_low_pass_3db_frequency", False, value) + + class _anglvel_accel_channels(_magn_channel): + """ADIS16480 gyro and accelerometer channels.""" + + def __init__(self, ctrl, channel_name): + self.name = channel_name + self._ctrl = ctrl + + @property + def calibscale(self): + """ADIS16480 calibscale value""" + return self._get_iio_attr(self.name, "calibscale", False) + + @calibscale.setter + def calibscale(self, value): + self._set_iio_attr(self.name, "calibscale", False, value) diff --git a/examples/adis16480_example.py b/examples/adis16480_example.py new file mode 100644 index 000000000..e24728758 --- /dev/null +++ b/examples/adis16480_example.py @@ -0,0 +1,47 @@ +# Copyright (C) 2021 Analog Devices, Inc. +# +# SPDX short identifier: ADIBSD + +import adi +import matplotlib.pyplot as plt + +# Set up ADIS16480 +dev = adi.adis16480(uri="ip:localhost", device_name="adis16480") + +dev.rx_output_type = "raw" +dev.rx_enabled_channels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +dev.sample_rate = 10 +dev.rx_buffer_size = 10 + + +print("\nX acceleration: " + str(dev.accel_x_conv) + " m/s^2") +print("Y acceleration: " + str(dev.accel_y_conv) + " m/s^2") +print("Z acceleration: " + str(dev.accel_z_conv) + " m/s^2") + +print("\nX angular velocity: " + str(dev.anglvel_x_conv) + " rad/s") +print("Y angular velocity: " + str(dev.anglvel_y_conv) + " rad/s") +print("Z angular velocity: " + str(dev.anglvel_z_conv) + " rad/s") + +dev.sample_rate = 2000 +dev.magn_x_filter_low_pass_3db_frequency = 100 +dev.anglvel_y_calibscale = 30 +dev.anglvel_x_calibbias = 100 + +print("Sampling frequency: " + str(dev.sample_rate)) + +print("Temperature raw value: " + str(dev.temp.raw)) +print("Temperature scale value: " + str(dev.temp.scale)) +print("Temperature offset value: " + str(dev.temp.offset)) + +print("X-axis gyro channel calibbias value: " + str(dev.anglvel_x_calibbias)) +print("X-axis gyro channel calibscale value: " + str(dev.anglvel_y_calibscale)) +print("X-axis magnetometer bandwidth: " + str(dev.magn_x_filter_low_pass_3db_frequency)) + +for _ in range(100): + data = dev.rx() + plt.clf() + for i, d in enumerate(data): + plt.plot(d, label=dev._rx_channel_names[i]) + plt.legend() + plt.show(block=False) + plt.pause(0.1) diff --git a/supported_parts.md b/supported_parts.md index e52795d8e..92959d027 100644 --- a/supported_parts.md +++ b/supported_parts.md @@ -122,6 +122,7 @@ - ADG2128 - ADIS16460 - ADIS16475 +- ADIS16480 - ADIS16495 - ADIS16507 - ADL5240 diff --git a/test/emu/devices/adis16480.xml b/test/emu/devices/adis16480.xml new file mode 100644 index 000000000..7325e52c4 --- /dev/null +++ b/test/emu/devices/adis16480.xml @@ -0,0 +1,2 @@ +]> \ No newline at end of file diff --git a/test/emu/hardware_map.yml b/test/emu/hardware_map.yml index e088bd9a9..6be956c1b 100644 --- a/test/emu/hardware_map.yml +++ b/test/emu/hardware_map.yml @@ -521,6 +521,15 @@ adis16475: - pyadi_iio_class_support: - adis16475 +adis16480: + - adis16480 + - emulate: + - filename: adis16480.xml + - data_devices: + - iio:device0 + - pyadi_iio_class_support: + - adis16480 + ad7124-8: - ad7124 - pyadi_iio_class_support: diff --git a/test/test_adis16480.py b/test/test_adis16480.py new file mode 100644 index 000000000..7b432d32c --- /dev/null +++ b/test/test_adis16480.py @@ -0,0 +1,81 @@ +import adi +import pytest + +hardware = "adis16480" +classname = "adi.adis16480" +device_name = "adis16480" + +######################################## +@pytest.mark.iio_hardware(hardware, True) +@pytest.mark.parametrize("classname", [(classname)]) +@pytest.mark.parametrize("channel", [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) +def test_adis16480_rx_data(test_dma_rx, iio_uri, classname, channel): + test_dma_rx(iio_uri, classname, channel, buffer_size=16) + + +######################################### +@pytest.mark.iio_hardware(hardware) +def test_adis16480_conv_data(iio_uri): + adis16480 = adi.adis16480(uri=iio_uri) + + assert adis16480.accel_x_conv != 0.0 + assert adis16480.accel_y_conv != 0.0 + assert adis16480.accel_z_conv != 0.0 + assert adis16480.anglvel_x_conv != 0.0 + assert adis16480.anglvel_y_conv != 0.0 + assert adis16480.anglvel_z_conv != 0.0 + assert adis16480.temp_conv != 0.0 + + +######################################### +@pytest.mark.iio_hardware(hardware) +@pytest.mark.parametrize("classname", [(classname)]) +@pytest.mark.parametrize( + "attr, start, stop, step, tol", + [ + ("anglvel_x_calibbias", -2147483648, 2147483647, 1, 0), + ("anglvel_y_calibbias", -2147483648, 2147483647, 1, 0), + ("anglvel_z_calibbias", -2147483648, 2147483647, 1, 0), + ("accel_x_calibbias", -2147483648, 2147483647, 1, 0), + ("accel_y_calibbias", -2147483648, 2147483647, 1, 0), + ("accel_z_calibbias", -2147483648, 2147483647, 1, 0), + ("magn_x_calibbias", -32134, 32134, 1, 0), + ("magn_y_calibbias", -32134, 32134, 1, 0), + ("magn_z_calibbias", -32134, 32134, 1, 0), + ("pressure_calibbias", -32134, 32134, 1, 0), + ("anglvel_x_calibscale", -32134, 32134, 1, 0), + ("anglvel_y_calibscale", -32134, 32134, 1, 0), + ("anglvel_z_calibscale", -32134, 32134, 1, 0), + ("accel_x_calibscale", -32134, 32134, 1, 0), + ("accel_y_calibscale", -32134, 32134, 1, 0), + ("accel_z_calibscale", -32134, 32134, 1, 0), + ], +) +def test_adis16480_attr( + test_attribute_single_value, iio_uri, classname, attr, start, stop, step, tol +): + test_attribute_single_value(iio_uri, classname, attr, start, stop, step, tol) + + +######################################### +@pytest.mark.iio_hardware(hardware, True) +@pytest.mark.parametrize("classname", [(classname)]) +@pytest.mark.parametrize( + "attr, values, tol, repeats", + [ + ("sample_rate", [5, 10, 246, 1230, 2460], 0.5, 2), + ("anglvel_x_filter_low_pass_3db_frequency", [0, 55, 275, 310], 0.5, 2), + ("anglvel_y_filter_low_pass_3db_frequency", [0, 55, 275, 310], 0.5, 2), + ("anglvel_z_filter_low_pass_3db_frequency", [0, 55, 275, 310], 0.5, 2), + ("accel_x_filter_low_pass_3db_frequency", [0, 55, 275, 310], 0.5, 2), + ("accel_y_filter_low_pass_3db_frequency", [0, 55, 275, 310], 0.5, 2), + ("accel_z_filter_low_pass_3db_frequency", [0, 55, 275, 310], 0.5, 2), + ("magn_x_filter_low_pass_3db_frequency", [0, 55, 275, 310], 0.5, 2), + ("magn_y_filter_low_pass_3db_frequency", [0, 55, 275, 310], 0.5, 2), + ("magn_z_filter_low_pass_3db_frequency", [0, 55, 275, 310], 0.5, 2), + ], +) +def test_adis16480_attr_multiple_val( + test_attribute_multiple_values, iio_uri, classname, attr, values, tol, repeats, +): + test_attribute_multiple_values(iio_uri, classname, attr, values, tol, repeats)