dotnet
diff --git a/Diff for: ‎src/devices/Ads1115/Ads1115.cs
+42-86 b/Diff for: ‎src/devices/Ads1115/Ads1115.cs
+42-86
diff --git a/Diff for: ‎src/devices/Adxl345/Adxl345.cs
+9-20 b/Diff for: ‎src/devices/Adxl345/Adxl345.cs
+9-20
diff --git a/Diff for: ‎src/devices/Adxl345/samples/Program.cs
+3-4 b/Diff for: ‎src/devices/Adxl345/samples/Program.cs
+3-4
diff --git a/Diff for: ‎src/devices/Ags01db/Ags01db.cs
+16-16 b/Diff for: ‎src/devices/Ags01db/Ags01db.cs
+16-16
@@ -47,8 +47,8 @@ public class Ads1115 : IDisposable
         /// <param name="measuringRange">Programmable Gain Amplifier</param>
         /// <param name="dataRate">Data Rate</param>
         /// <param name="deviceMode">Initial device mode</param>
-        public Ads1115(I2cDevice i2cDevice, InputMultiplexer inputMultiplexer = InputMultiplexer.AIN0, MeasuringRange measuringRange = MeasuringRange.FS4096, DataRate dataRate = DataRate.SPS128,
-            DeviceMode deviceMode = DeviceMode.Continuous)
+        public Ads1115(I2cDevice i2cDevice, InputMultiplexer inputMultiplexer = InputMultiplexer.AIN0, MeasuringRange measuringRange = MeasuringRange.FS4096,
+            DataRate dataRate = DataRate.SPS128, DeviceMode deviceMode = DeviceMode.Continuous)
         {
             _i2cDevice = i2cDevice ?? throw new ArgumentNullException(nameof(i2cDevice));
             _inputMultiplexer = inputMultiplexer;
@@ -61,7 +61,6 @@ public Ads1115(I2cDevice i2cDevice, InputMultiplexer inputMultiplexer = InputMul
             _comparatorPolarity = ComparatorPolarity.Low;
             _comparatorLatching = ComparatorLatching.NonLatching;
             _comparatorQueue = ComparatorQueue.Disable;
-            _shouldDispose = false;
 
             SetConfig();
             DisableAlertReadyPin();
@@ -79,18 +78,18 @@ public Ads1115(I2cDevice i2cDevice, InputMultiplexer inputMultiplexer = InputMul
         /// <param name="dataRate">Data Rate</param>
         /// <param name="deviceMode">Initial device mode</param>
         public Ads1115(I2cDevice i2cDevice,
-            GpioController gpioController, int gpioInterruptPin, bool shouldDispose = true, InputMultiplexer inputMultiplexer = InputMultiplexer.AIN0, MeasuringRange measuringRange = MeasuringRange.FS4096, DataRate dataRate = DataRate.SPS128,
-            DeviceMode deviceMode = DeviceMode.Continuous)
+            GpioController? gpioController, int gpioInterruptPin, bool shouldDispose = true, InputMultiplexer inputMultiplexer = InputMultiplexer.AIN0, MeasuringRange measuringRange = MeasuringRange.FS4096,
+            DataRate dataRate = DataRate.SPS128, DeviceMode deviceMode = DeviceMode.Continuous)
             : this(i2cDevice, inputMultiplexer, measuringRange, dataRate, deviceMode)
         {
-            _gpioController = gpioController ?? throw new ArgumentNullException(nameof(gpioController));
-            if (gpioInterruptPin < 0 || gpioInterruptPin >= gpioController.PinCount)
+            _gpioController = gpioController ?? new GpioController();
+            if (gpioInterruptPin < 0 || gpioInterruptPin >= _gpioController.PinCount)
             {
                 throw new ArgumentOutOfRangeException(nameof(gpioInterruptPin), $"The given GPIO Controller has no pin number {gpioInterruptPin}");
             }
 
             _gpioInterruptPin = gpioInterruptPin;
-            _shouldDispose = shouldDispose;
+            _shouldDispose = shouldDispose || gpioController is null;
         }
 
         /// <summary>
@@ -164,11 +163,7 @@ public DeviceMode DeviceMode
         /// Comparator mode.
         /// Only relevant if the comparator trigger event is set up and is changed by <see cref="EnableComparator(short, short, ComparatorMode, ComparatorQueue)"/>.
         /// </summary>
-        public ComparatorMode ComparatorMode
-        {
-            get;
-            private set;
-        }
+        public ComparatorMode ComparatorMode { get; private set; }
 
         /// <summary>
         /// Comparator polarity. Indicates whether the rising or the falling edge of the ALRT/RDY Pin is relevant.
@@ -208,13 +203,7 @@ public ComparatorLatching ComparatorLatching
         /// Minimum number of samples exceeding the lower/upper threshold before the ALRT pin is asserted.
         /// This can only be set with <see cref="EnableComparator(short, short, ComparatorMode, ComparatorQueue)"/>.
         /// </summary>
-        public ComparatorQueue ComparatorQueue
-        {
-            get
-            {
-                return _comparatorQueue;
-            }
-        }
+        public ComparatorQueue ComparatorQueue => _comparatorQueue;
 
         /// <summary>
         /// This event fires when a new value is available (in conversion ready mode) or the comparator threshold is exceeded.
@@ -285,7 +274,7 @@ private void DisableAlertReadyPin()
                 (byte)Register.ADC_CONFIG_REG_HI_THRESH, 0x7F, 0xFF
             };
             _i2cDevice.Write(writeBuff);
-            if (_gpioController != null)
+            if (_gpioController is object)
             {
                 _gpioController.UnregisterCallbackForPinValueChangedEvent(_gpioInterruptPin, ConversionReadyCallback);
                 _gpioController.ClosePin(_gpioInterruptPin);
@@ -319,7 +308,7 @@ private void WriteComparatorRegisters(short loThreshold, short hiThreshold)
         /// for interrupt handling.</exception>
         public void EnableConversionReady()
         {
-            if (_gpioController == null)
+            if (_gpioController is null)
             {
                 throw new InvalidOperationException("Must have provided a GPIO Controller for interrupt handling.");
             }
@@ -349,7 +338,7 @@ public void EnableConversionReady()
 
         private void ConversionReadyCallback(object sender, PinValueChangedEventArgs pinValueChangedEventArgs)
         {
-            if (AlertReadyAsserted != null)
+            if (AlertReadyAsserted is object)
             {
                 AlertReadyAsserted();
             }
@@ -368,10 +357,7 @@ private void ConversionReadyCallback(object sender, PinValueChangedEventArgs pin
         /// <param name="queueLength">Minimum number of samples that must exceed the threshold to trigger the event</param>
         /// <exception cref="InvalidOperationException">The GPIO Controller for the interrupt handler has not been set up</exception>
         public void EnableComparator(ElectricPotential lowerValue, ElectricPotential upperValue, ComparatorMode mode,
-            ComparatorQueue queueLength)
-        {
-            EnableComparator(VoltageToRaw(lowerValue), VoltageToRaw(upperValue), mode, queueLength);
-        }
+            ComparatorQueue queueLength) => EnableComparator(VoltageToRaw(lowerValue), VoltageToRaw(upperValue), mode, queueLength);
 
         /// <summary>
         /// Enable comparator callback mode.
@@ -388,7 +374,7 @@ public void EnableComparator(ElectricPotential lowerValue, ElectricPotential upp
         public void EnableComparator(short lowerValue, short upperValue, ComparatorMode mode,
             ComparatorQueue queueLength)
         {
-            if (_gpioController == null)
+            if (_gpioController is null)
             {
                 throw new InvalidOperationException("GPIO Controller must have been provided in constructor for this operation to work");
             }
@@ -444,7 +430,7 @@ private ushort ReadConfigRegister()
         /// This method must only be called in powerdown mode, otherwise it would timeout, since the busy bit never changes.
         /// Due to that, we always write the configuration first in power down mode and then enable the continuous bit.
         /// </summary>
-        /// <exception cref="TimeoutException">A timeout occured waiting for the ADC to finish the conversion</exception>
+        /// <exception cref="TimeoutException">A timeout occurred waiting for the ADC to finish the conversion</exception>
         private void WaitWhileBusy()
         {
             // In powerdown-mode, wait until the busy bit goes high
@@ -502,10 +488,7 @@ private short ReadRawInternal()
         /// For performance reasons, it is advised to use this method if quick readings with different input channels are required,
         /// instead of setting all the properties first and then calling <see cref="ReadRaw()"/>.
         /// </remarks>
-        public short ReadRaw(InputMultiplexer inputMultiplexer)
-        {
-            return ReadRaw(inputMultiplexer, MeasuringRange, DataRate);
-        }
+        public short ReadRaw(InputMultiplexer inputMultiplexer) => ReadRaw(inputMultiplexer, MeasuringRange, DataRate);
 
         /// <summary>
         /// Reads the next raw value, first switching to the given input and ranges.
@@ -590,30 +573,16 @@ public short VoltageToRaw(ElectricPotential voltage)
         /// <returns>An electric potential (voltage).</returns>
         public ElectricPotential MaxVoltageFromMeasuringRange(MeasuringRange measuringRange)
         {
-            double voltage;
-            switch (measuringRange)
-            {
-                case MeasuringRange.FS6144:
-                    voltage = 6.144;
-                    break;
-                case MeasuringRange.FS4096:
-                    voltage = 4.096;
-                    break;
-                case MeasuringRange.FS2048:
-                    voltage = 2.048;
-                    break;
-                case MeasuringRange.FS1024:
-                    voltage = 1.024;
-                    break;
-                case MeasuringRange.FS0512:
-                    voltage = 0.512;
-                    break;
-                case MeasuringRange.FS0256:
-                    voltage = 0.256;
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(measuringRange), "Unknown measuring range used");
-            }
+            double voltage = measuringRange switch
+            {
+                MeasuringRange.FS6144 => 6.144,
+                MeasuringRange.FS4096 => 4.096,
+                MeasuringRange.FS2048 => 2.048,
+                MeasuringRange.FS1024 => 1.024,
+                MeasuringRange.FS0512 => 0.512,
+                MeasuringRange.FS0256 => 0.256,
+                _ => throw new ArgumentOutOfRangeException(nameof(measuringRange), "Unknown measuring range used")
+            };
 
             return ElectricPotential.FromVolts(voltage);
         }
@@ -623,50 +592,37 @@ public ElectricPotential MaxVoltageFromMeasuringRange(MeasuringRange measuringRa
         /// </summary>
         /// <param name="dataRate">One of the <see cref="DataRate"/> enumeration members.</param>
         /// <returns>A frequency, in Hertz</returns>
-        public double FrequencyFromDataRate(DataRate dataRate)
+        public double FrequencyFromDataRate(DataRate dataRate) => dataRate switch
         {
-            switch (dataRate)
-            {
-                case DataRate.SPS008:
-                    return 8.0;
-                case DataRate.SPS016:
-                    return 16.0;
-                case DataRate.SPS032:
-                    return 32.0;
-                case DataRate.SPS064:
-                    return 64.0;
-                case DataRate.SPS128:
-                    return 128.0;
-                case DataRate.SPS250:
-                    return 250.0;
-                case DataRate.SPS475:
-                    return 475.0;
-                case DataRate.SPS860:
-                    return 860.0;
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(dataRate), "Unknown data rate used");
-            }
-        }
+                DataRate.SPS008 => 8.0,
+                DataRate.SPS016 => 16.0,
+                DataRate.SPS032 => 32.0,
+                DataRate.SPS064 => 64.0,
+                DataRate.SPS128 => 128.0,
+                DataRate.SPS250 => 250.0,
+                DataRate.SPS475 => 475.0,
+                DataRate.SPS860 => 860.0,
+                _ => throw new ArgumentOutOfRangeException(nameof(dataRate), "Unknown data rate used")
+        };
 
         /// <summary>
         /// Cleanup.
         /// Failing to dispose this class, especially when callbacks are active, may lead to undefined behavior.
         /// </summary>
         public void Dispose()
         {
-            if (_i2cDevice != null)
+            if (_i2cDevice is object)
             {
                 DisableAlertReadyPin();
-                _i2cDevice?.Dispose();
+                _i2cDevice.Dispose();
                 _i2cDevice = null!;
             }
 
-            if (_shouldDispose && _gpioController != null)
+            if (_shouldDispose)
             {
-                _gpioController.Dispose();
+                _gpioController?.Dispose();
+                _gpioController = null;
             }
-
-            _gpioController = null;
         }
     }
 }
@@ -45,27 +45,16 @@ public class Adxl345 : IDisposable
         /// <param name="gravityRange">Gravity Measurement Range</param>
         public Adxl345(SpiDevice sensor, GravityRange gravityRange)
         {
-            if (gravityRange == GravityRange.Range02)
+            _sensor = sensor ?? throw new ArgumentNullException(nameof(sensor));
+            _range = gravityRange switch
             {
-                _range = 4;
-            }
-            else if (gravityRange == GravityRange.Range04)
-            {
-                _range = 8;
-            }
-            else if (gravityRange == GravityRange.Range08)
-            {
-                _range = 16;
-            }
-            else if (gravityRange == GravityRange.Range16)
-            {
-                _range = 32;
-            }
-
+                GravityRange.Range02 => 4,
+                GravityRange.Range04 => 8,
+                GravityRange.Range08 => 16,
+                GravityRange.Range16 => 32,
+                _ => 0
+            };
             _gravityRangeByte = (byte)gravityRange;
-
-            _sensor = sensor;
-
             Initialize();
         }
 
@@ -119,7 +108,7 @@ private Vector3 ReadAcceleration()
         /// </summary>
         public void Dispose()
         {
-            if (_sensor != null)
+            if (_sensor is object)
             {
                 _sensor.Dispose();
                 _sensor = null!;
 
@@ -9,14 +9,13 @@
 
 SpiConnectionSettings settings = new (0, 0)
 {
-    ClockFrequency = Iot.Device.Adxl345.Adxl345.SpiClockFrequency,
-    Mode = Iot.Device.Adxl345.Adxl345.SpiMode
+    ClockFrequency = Adxl345.SpiClockFrequency,
+    Mode = Adxl345.SpiMode
 };
 
 using SpiDevice device = SpiDevice.Create(settings);
-
 // set gravity measurement range ±4G
-using Iot.Device.Adxl345.Adxl345 sensor = new Iot.Device.Adxl345.Adxl345(device, GravityRange.Range04);
+using Adxl345 sensor = new Adxl345(device, GravityRange.Range04);
 while (true)
 {
     // read data
 
@@ -18,17 +18,17 @@ public class Ags01db : IDisposable
         private const byte CRC_INIT = 0xFF;
         private I2cDevice _i2cDevice;
 
-        private int _lastMeasurment = 0;
+        private int _lastMeasurement = 0;
 
         /// <summary>
         /// ASG01DB VOC (Volatile Organic Compounds) Gas Concentration (ppm)
         /// </summary>
-        public double Concentration { get => GetConcentration(); }
+        public double Concentration => GetConcentration();
 
         /// <summary>
         /// ASG01DB Version
         /// </summary>
-        public byte Version { get => GetVersion(); }
+        public byte Version => GetVersion();
 
         /// <summary>
         /// ASG01DB Default I2C Address
@@ -41,16 +41,7 @@ public class Ags01db : IDisposable
         /// <param name="i2cDevice">The I2C device used for communication.</param>
         public Ags01db(I2cDevice i2cDevice)
         {
-            _i2cDevice = i2cDevice;
-        }
-
-        /// <summary>
-        /// Cleanup
-        /// </summary>
-        public void Dispose()
-        {
-            _i2cDevice?.Dispose();
-            _i2cDevice = null!;
+            _i2cDevice = i2cDevice ?? throw new ArgumentNullException(nameof(i2cDevice));
         }
 
         /// <summary>
@@ -60,9 +51,9 @@ public void Dispose()
         private double GetConcentration()
         {
             // The time of two measurements should be more than 2s.
-            while (Environment.TickCount - _lastMeasurment < 2000)
+            while (Environment.TickCount - _lastMeasurement < 2000)
             {
-                Thread.Sleep(TimeSpan.FromMilliseconds(Environment.TickCount - _lastMeasurment));
+                Thread.Sleep(Environment.TickCount - _lastMeasurement);
             }
 
             // Details in the Datasheet P5
@@ -77,7 +68,7 @@ private double GetConcentration()
             _i2cDevice.Write(writeBuff);
             _i2cDevice.Read(readBuff);
 
-            _lastMeasurment = Environment.TickCount;
+            _lastMeasurement = Environment.TickCount;
 
             // CRC check error
             if (!CheckCrc8(readBuff.Slice(0, 2), 2, readBuff[2]))
@@ -154,5 +145,14 @@ private bool CheckCrc8(ReadOnlySpan<byte> data, int length, byte crc8)
                 return false;
             }
         }
+
+        /// <summary>
+        /// Cleanup
+        /// </summary>
+        public void Dispose()
+        {
+            _i2cDevice?.Dispose();
+            _i2cDevice = null!;
+        }
     }
 }