Merge pull request #392 from oss-slu/380-refactor-adcconverterhelper

first submission of complete test, helper and controller

Author: leandrumartin

components/src/main/java/com/opensourcewithslu/components/controllers/ADC0834ConverterController.java

@@ -0,0 +1,55 @@
+package com.opensourcewithslu.components.controllers;
+
+import com.pi4j.io.spi.Spi;
+import com.opensourcewithslu.inputdevices.ADC0834ConverterHelper;
+import io.micronaut.http.annotation.Controller;
+import io.micronaut.http.annotation.Get;
+import jakarta.inject.Named;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * ADC0834ConverterController provides an endpoint to read values from the ADC0834.
+ */
+@Controller("/adc0834")
+public class ADC0834ConverterController {
+    private static final Logger log = LoggerFactory.getLogger(ADC0834ConverterController.class);
+    private final ADC0834ConverterHelper adcConverterHelper;
+
+    /**
+     * Constructor for ADC0834ConverterController.
+     *
+     * @param spi SPI interface
+     */
+    public ADC0834ConverterController(@Named("adc0834") Spi spi) {
+        this.adcConverterHelper = new ADC0834ConverterHelper(spi);
+        log.info("ADC0834ConverterController initialized with SPI");
+    }
+
+    /**
+     * Endpoint to get the digital value from the specified ADC0834 channel.
+     *
+     * @param channel The ADC channel to read (0-3).
+     * @return The digital value read from the ADC0834.
+     */
+    @Get("/read/{channel}")
+    public int readValue(int channel) {
+        int value = adcConverterHelper.readValue(channel);
+        log.info("Value retrieved from ADC0834: {}", value);
+        return value;
+    }
+
+    /**
+     * Endpoint to get the voltage from the specified ADC0834 channel.
+     *
+     * @param channel The ADC channel to read (0-3).
+     * @param referenceVoltage The reference voltage for the ADC.
+     * @return The voltage value read from the ADC0834.
+     */
+    @Get("/voltage/{channel}/{referenceVoltage}")
+    public double readVoltage(int channel, double referenceVoltage) {
+        double voltage = adcConverterHelper.readVoltage(channel, referenceVoltage);
+        log.info("Voltage retrieved from ADC0834 channel {}: {}V", channel, voltage);
+        return voltage;
+    }
+}

components/src/main/java/com/opensourcewithslu/components/controllers/ADCConverterController.java

@@ -10,8 +10,8 @@ pi4j:
       address: 8            # <3>
       baud: 500000          # <4>
       reset-pin: 25         # <5>
-    thermistor-adc: # Configuration for Thermistor ADC
-      name: Thermistor ADC  # <1>
+    adc0834: # Configuration for ADC0834
+      name: ADC0834  # <1>
       address: 17            # <2> # SPI channel 0
       baud: 1000000         # <3> # 1 MHz SPI clock speed
       mode: SPI_MODE_0

components/src/main/resources/application.yml

@@ -0,0 +1,70 @@
+package com.opensourcewithslu.inputdevices;
+
+import com.pi4j.io.spi.Spi;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The ADC0834ConverterHelper class interfaces with the ADC0834 analog-to-digital converter using SPI.
+ * It provides methods to read digital values and voltages from the specified channel.
+ */
+public class ADC0834ConverterHelper {
+    private static final Logger log = LoggerFactory.getLogger(ADC0834ConverterHelper.class);
+    private final Spi spi;
+
+    /**
+     * Constructor for ADC0834ConverterHelper.
+     * @param spi The SPI interface.
+     */
+    public ADC0834ConverterHelper(Spi spi) {
+        this.spi = spi;
+        log.info("ADC0834ConverterHelper initialized with SPI");
+    }
+
+    /**
+     * Reads the digital value from the specified channel (0-3) of the ADC0834.
+     * @param channel The ADC channel to read (0-3).
+     * @return The 8-bit digital value (0-255).
+     * @throws IllegalArgumentException if channel is invalid.
+     */
+    public int readValue(int channel) {
+        if (channel < 0 || channel > 3) {
+            log.error("Invalid channel: {}. Must be 0-3.", channel);
+            throw new IllegalArgumentException("Channel must be between 0 and 3");
+        }
+
+        // ADC0834 control byte: Start bit (1), single-ended (1), channel select (2 bits), reserved (0)
+        byte controlByte = (byte) (0b10000000 | (channel << 5));
+        byte[] txBuffer = new byte[] { controlByte, 0 }; // Second byte for clocking out data
+        byte[] rxBuffer = new byte[2];
+
+        try {
+            spi.transfer(txBuffer, rxBuffer);
+            int digitalValue = rxBuffer[1] & 0xFF; // 8-bit result
+            log.info("Read channel {}: raw value = {}", channel, digitalValue);
+            return digitalValue;
+        } catch (Exception e) {
+            log.error("Failed to read from ADC0834 on channel {}: {}", channel, e.getMessage());
+            throw new RuntimeException("SPI communication error", e);
+        }
+    }
+
+    /**
+     * Reads the voltage from the specified channel using the provided reference voltage.
+     * @param channel The ADC channel to read (0-3).
+     * @param referenceVoltage The reference voltage (e.g., 3.3V or 5.0V).
+     * @return The measured voltage.
+     * @throws IllegalArgumentException if channel or referenceVoltage is invalid.
+     */
+    public double readVoltage(int channel, double referenceVoltage) {
+        if (referenceVoltage <= 0) {
+            log.error("Invalid reference voltage: {}. Must be positive.", referenceVoltage);
+            throw new IllegalArgumentException("Reference voltage must be positive");
+        }
+
+        int rawValue = readValue(channel);
+        double voltage = (rawValue / 255.0) * referenceVoltage;
+        log.info("Channel {} voltage: {}V (raw = {}, ref = {}V)", channel, voltage, rawValue, referenceVoltage);
+        return voltage;
+    }
+}

pi4micronaut-utils/src/main/java/com/opensourcewithslu/inputdevices/ADC0834ConverterHelper.java

@@ -0,0 +1,89 @@
+package com.opensourcewithslu.inputdevices;
+
+import com.pi4j.context.Context;
+import com.pi4j.io.spi.Spi;
+import com.pi4j.io.spi.SpiConfig;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+public class ADC0834ConverterHelperTest {
+    private static final Logger log = LoggerFactory.getLogger(ADC0834ConverterHelperTest.class);
+
+    private Context mockContext;
+    private Spi mockSpi;
+    private ADC0834ConverterHelper adc;
+
+    @BeforeEach
+    public void setUp() {
+        mockContext = Mockito.mock(Context.class);
+        mockSpi = Mockito.mock(Spi.class);
+        when(mockContext.create(any(SpiConfig.class))).thenReturn(mockSpi);
+        adc = new ADC0834ConverterHelper(mockSpi);
+    }
+
+    @Test
+    public void testReadValueValidChannel() throws Exception {
+        // Mock the transfer(byte[], byte[]) method
+        doAnswer(invocation -> {
+            byte[] txBuffer = invocation.getArgument(0);
+            byte[] rxBuffer = invocation.getArgument(1);
+            // Simulate ADC0834 response - 8-bit value in rxBuffer[1]
+            rxBuffer[0] = 0x00;  // First byte unused
+            rxBuffer[1] = (byte) 0x80;  // 8-bit value: 128 (decimal)
+            return null;
+        }).when(mockSpi).transfer(any(byte[].class), any(byte[].class));
+
+        int value = adc.readValue(2);
+        assertEquals(128, value, "ADC value should be 128 (8-bit)");
+    }
+
+    @Test
+    public void testReadValueInvalidChannelLow() {
+        Exception exception = assertThrows(IllegalArgumentException.class, () -> adc.readValue(-1));
+        assertEquals("Channel must be between 0 and 3", exception.getMessage());
+    }
+
+    @Test
+    public void testReadValueInvalidChannelHigh() {
+        Exception exception = assertThrows(IllegalArgumentException.class, () -> adc.readValue(4));
+        assertEquals("Channel must be between 0 and 3", exception.getMessage());
+    }
+
+    @Test
+    public void testReadVoltageValid() throws Exception {
+        // Mock the transfer method to return value 128
+        doAnswer(invocation -> {
+            byte[] txBuffer = invocation.getArgument(0);
+            byte[] rxBuffer = invocation.getArgument(1);
+            rxBuffer[0] = 0x00;
+            rxBuffer[1] = (byte) 0x80;  // 128 in decimal
+            return null;
+        }).when(mockSpi).transfer(any(byte[].class), any(byte[].class));
+
+        double voltage = adc.readVoltage(1, 3.3);
+        // Expected: (128 / 255.0) * 3.3 = 1.654...
+        assertEquals(3.3 * (128.0 / 255.0), voltage, 0.001, "Voltage should be correctly calculated (8-bit)");
+    }
+
+    @Test
+    public void testReadVoltageInvalidReference() {
+        Exception exception = assertThrows(IllegalArgumentException.class, () -> adc.readVoltage(0, 0));
+        assertEquals("Reference voltage must be positive", exception.getMessage());
+    }
+
+    @Test
+    public void testSpiCommunicationFailure() throws Exception {
+        // Mock transfer to throw exception
+        doThrow(new RuntimeException("SPI error")).when(mockSpi).transfer(any(byte[].class), any(byte[].class));
+        
+        Exception exception = assertThrows(RuntimeException.class, () -> adc.readValue(0));
+        assertTrue(exception.getMessage().contains("SPI"), "Expected SPI-related error");
+    }
+}