ADC DMA Driver (#93)

Co-authored-by: Alexander Bessman <[email protected]>

Author: Tejasgarg

src/application/main.c

@@ -23,17 +23,21 @@
 
 // Callback when at least 5 bytes are available
 #define CB_THRESHOLD (sizeof("Hello") - 1)
+
 enum { RX_BUFFER_SIZE = 256 };
+enum { ADC_BUFFER_SIZE = 256 }; // Size of ADC buffer for DMA
 
 /*****************************************************************************
  * Static variables
  ******************************************************************************/
 
 static uint8_t g_usb_rx_buffer_data[RX_BUFFER_SIZE] = { 0 };
-static bool g_usb_service_requested = false;
+// Buffer for USB RX data
+static uint16_t g_adc_buffer_data[ADC_BUFFER_SIZE] = { 0 };
+// Buffer for ADC data
 
-uint32_t volatile g_latest_adc_value = 0;
-bool volatile g_adc_data_ready = false;
+static bool g_usb_service_requested = false;
+bool volatile g_adc_ready = false;
 
 /*****************************************************************************
  * Static prototypes
@@ -52,10 +56,12 @@ void usb_cb(USB_Handle *husb, uint32_t bytes_available)
     LOG_FUNCTION_EXIT();
 }
 
-static void g_adc_callback(uint32_t value)
+static void adc_cb(ADC_Handle *hadc)
 {
-    g_latest_adc_value = value; // Store the latest ADC value
-    g_adc_data_ready = true; // Set a flag to indicate new data is ready
+    LOG_FUNCTION_ENTRY();
+    (void)hadc;
+    g_adc_ready = true; // Set flag to indicate ADC data is ready
+    LOG_FUNCTION_EXIT();
 }
 
 int main(void) // NOLINT
@@ -88,11 +94,14 @@ int main(void) // NOLINT
     circular_buffer_init(&usb_rx_buf, g_usb_rx_buffer_data, RX_BUFFER_SIZE);
     USB_Handle *husb = USB_init(0, &usb_rx_buf);
 
+    ADC_init(g_adc_buffer_data, ADC_BUFFER_SIZE);
+
     USB_set_rx_callback(husb, usb_cb, CB_THRESHOLD);
-    // Initialize ADC
-    ADC_init();
-    ADC_set_complete_callback(g_adc_callback);
-    ADC_start(); // Start ADC conversions
+    ADC_set_callback(adc_cb);
+
+    // Start ADC conversions
+    ADC_start();
+
     /* Basic USB/LED example:
      * - Process incoming bytes when USB callback is triggered
      * - If a byte is received, toggle the LED
@@ -113,12 +122,22 @@ int main(void) // NOLINT
             LOG_INFO("System running, USB active");
         }
 
-        if (g_adc_data_ready) {
-            g_adc_data_ready = false; // Reset flag
-            LED_toggle(); // Toggle LED to indicate ADC data ready
-            LOG_INFO(
-                "ADC Value: %u", (unsigned int)g_latest_adc_value
-            ); // Log the ADC value
+        if (g_adc_ready) {
+            g_adc_ready = false;
+            LED_toggle();
+            uint16_t buf[ADC_BUFFER_SIZE] = { 0 };
+            uint32_t samples_read = ADC_read(buf, ADC_BUFFER_SIZE);
+
+            if (samples_read > 0) {
+
+                uint16_t num_samples = samples_read;
+                for (uint32_t i = 0; i < num_samples; i++) {
+                    LOG_INFO("Sample %u: %u", i + 1, buf[i]);
+                }
+            } else {
+                LOG_ERROR("ADC read failed or no data available");
+            }
+            ADC_restart(); // Restart ADC for next conversion
         }
 
         if (g_usb_service_requested) {

src/platform/adc_ll.h

@@ -17,14 +17,30 @@ typedef enum {
     ADC_TRIGGER_TIMER7 = 7
 } ADC_LL_TriggerSource;
 
-typedef void (*ADC_LL_CompleteCallback)(uint32_t value);
+/**
+ * @brief Callback function type for ADC complete events.
+ *
+ * This callback is called when the ADC conversion is complete.
+ * It receives the DMA position as an argument.
+ * @param dma_pos Current DMA position.
+ */
+typedef void (*ADC_LL_CompleteCallback)(void);
 
 /**
  * @brief Initializes the ADC1 peripheral.
  *
  * This function configures the ADC1 peripheral with the specified settings.
+ * It must be called before any ADC operations can be performed.
+ *
+ * @param adc_buf Pointer to the ADC data buffer.
+ * @param sz Size of the ADC data buffer.
+ * @param adc_trigger_timer Trigger source for the ADC (e.g., timer).
  */
-void ADC_LL_init(ADC_LL_TriggerSource adc_trigger_timer);
+void ADC_LL_init(
+    uint16_t *adc_buf,
+    uint32_t sz,
+    ADC_LL_TriggerSource adc_trigger_timer
+);
 
 /**
  * @brief Deinitializes the ADC peripheral.
@@ -51,11 +67,10 @@ void ADC_LL_start(void);
 void ADC_LL_stop(void);
 
 /**
- * @brief Sets the callback function to be called when an ADC conversion is
- * complete.
+ * @brief Sets the callback for ADC completion events.
  *
- * This function allows the user to set a callback that will be invoked
- * when an ADC conversion is complete.
+ * This function sets a user-defined callback that will be called when
+ * the ADC conversion is complete.
  *
  * @param callback Pointer to the callback function to be set.
  */

src/platform/h563xx/adc_ll.c

@@ -22,11 +22,27 @@
 
 enum { ADC_IRQ_PRIORITY = 1 }; // ADC interrupt priority
 
+typedef struct {
+    ADC_HandleTypeDef *adc_handle; // Pointer to the ADC handle
+    ADC_ChannelConfTypeDef adc_config; // ADC channel configuration
+    DMA_HandleTypeDef *dma_handle; // Pointer to the DMA handle
+    uint16_t *adc_buffer_data; // Pointer to the ADC data buffer
+    uint32_t adc_buffer_size; // Size of the ADC data buffer
+    ADC_LL_CompleteCallback
+        adc_complete_callback; // Callback for ADC completion
+    bool initialized; // Flag to indicate if the ADC is initialized
+} ADCInstance;
+
 static ADC_HandleTypeDef g_hadc = { nullptr };
 
 static ADC_ChannelConfTypeDef g_config = { 0 };
 
-static ADC_LL_CompleteCallback volatile g_adc_complete_callback;
+static DMA_HandleTypeDef g_hdma_adc = { nullptr };
+
+static ADCInstance g_adc_instance = {
+    .adc_handle = &g_hadc,
+    .dma_handle = &g_hdma_adc,
+};
 
 /**
  * @brief Initializes the ADC MSP (MCU Support Package).
@@ -45,16 +61,42 @@ void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc)
     __HAL_RCC_ADC_CLK_ENABLE();
     // Enable GPIOA clock
     __HAL_RCC_GPIOA_CLK_ENABLE();
+    // Enable DMA1 clock
+    __HAL_RCC_GPDMA1_CLK_ENABLE();
 
     // Configure GPIO pin for ADC1_IN0 (PA0)
     gpio_init.Pin = GPIO_PIN_0; // PA0
     gpio_init.Mode = GPIO_MODE_ANALOG;
     gpio_init.Pull = GPIO_NOPULL;
     HAL_GPIO_Init(GPIOA, &gpio_init);
 
+    /*DMA for the ADC*/
+    g_hdma_adc.Instance = GPDMA1_Channel6; // DMA channel for ADC1
+    g_hdma_adc.Init.Request = GPDMA1_REQUEST_ADC1;
+    g_hdma_adc.Init.BlkHWRequest = DMA_BREQ_SINGLE_BURST;
+    g_hdma_adc.Init.Direction = DMA_PERIPH_TO_MEMORY;
+    g_hdma_adc.Init.SrcInc = DMA_SINC_FIXED;
+    g_hdma_adc.Init.DestInc = DMA_DINC_INCREMENTED;
+    g_hdma_adc.Init.SrcDataWidth = DMA_SRC_DATAWIDTH_HALFWORD;
+    g_hdma_adc.Init.DestDataWidth = DMA_DEST_DATAWIDTH_HALFWORD;
+    g_hdma_adc.Init.Priority = DMA_LOW_PRIORITY_LOW_WEIGHT;
+    g_hdma_adc.Init.SrcBurstLength = 1;
+    g_hdma_adc.Init.DestBurstLength = 1;
+    g_hdma_adc.Init.TransferAllocatedPort =
+        (DMA_SRC_ALLOCATED_PORT0 | DMA_DEST_ALLOCATED_PORT0);
+    g_hdma_adc.Init.TransferEventMode = DMA_TCEM_BLOCK_TRANSFER;
+    g_hdma_adc.Init.Mode = DMA_NORMAL;
+    if (HAL_DMA_Init(&g_hdma_adc) != HAL_OK) {
+        THROW(ERROR_HARDWARE_FAULT);
+    }
+    __HAL_LINKDMA(&g_hadc, DMA_Handle, g_hdma_adc);
+
     // Enable ADC1 interrupt
     HAL_NVIC_SetPriority(ADC1_IRQn, ADC_IRQ_PRIORITY, 0);
     HAL_NVIC_EnableIRQ(ADC1_IRQn);
+
+    HAL_NVIC_SetPriority(GPDMA1_Channel6_IRQn, ADC_IRQ_PRIORITY, 1);
+    HAL_NVIC_EnableIRQ(GPDMA1_Channel6_IRQn);
 }
 
 /**
@@ -65,52 +107,75 @@ void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc)
  * parameters.
  *
  */
-void ADC_LL_init(ADC_LL_TriggerSource adc_trigger_timer)
+void ADC_LL_init(
+    uint16_t *adc_buf,
+    uint32_t sz,
+    ADC_LL_TriggerSource adc_trigger_timer
+)
 {
+    if (adc_buf == nullptr || sz == 0) {
+        THROW(ERROR_INVALID_ARGUMENT);
+        return;
+    }
+
+    if (g_adc_instance.initialized) {
+        THROW(ERROR_RESOURCE_BUSY);
+        return;
+    }
+
+    // Initialize the ADC handle
+    ADCInstance *instance = &g_adc_instance;
 
     // Initialize the ADC peripheral
-    g_hadc.Instance = ADC1;
-    g_hadc.Init.ClockPrescaler =
+    instance->adc_handle->Instance = ADC1;
+    instance->adc_handle->Init.ClockPrescaler =
         ADC_CLOCK_SYNC_PCLK_DIV1; // ADC clock and prescaler
-    g_hadc.Init.Resolution = ADC_RESOLUTION_12B;
-    g_hadc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
-    g_hadc.Init.ScanConvMode = DISABLE;
-    g_hadc.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
-    g_hadc.Init.LowPowerAutoWait = DISABLE;
-    g_hadc.Init.ContinuousConvMode = DISABLE;
-    g_hadc.Init.NbrOfConversion = 1;
-    g_hadc.Init.DiscontinuousConvMode = DISABLE;
+    instance->adc_handle->Init.Resolution = ADC_RESOLUTION_12B;
+    instance->adc_handle->Init.DataAlign = ADC_DATAALIGN_RIGHT;
+    instance->adc_handle->Init.ScanConvMode = DISABLE;
+    instance->adc_handle->Init.EOCSelection = ADC_EOC_SINGLE_CONV;
+    instance->adc_handle->Init.LowPowerAutoWait = DISABLE;
+    instance->adc_handle->Init.ContinuousConvMode = DISABLE;
+    instance->adc_handle->Init.NbrOfConversion = 1;
+    instance->adc_handle->Init.DiscontinuousConvMode = DISABLE;
     if (adc_trigger_timer == ADC_TRIGGER_TIMER6) {
-        g_hadc.Init.ExternalTrigConv = ADC_EXTERNALTRIG_T6_TRGO;
+        instance->adc_handle->Init.ExternalTrigConv = ADC_EXTERNALTRIG_T6_TRGO;
     } else {
         THROW(ERROR_INVALID_ARGUMENT);
         return;
     }
-    g_hadc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
-    g_hadc.Init.SamplingMode = ADC_SAMPLING_MODE_NORMAL;
-    g_hadc.Init.DMAContinuousRequests = DISABLE;
-    g_hadc.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
-    g_hadc.Init.OversamplingMode = DISABLE;
+    instance->adc_handle->Init.ExternalTrigConvEdge =
+        ADC_EXTERNALTRIGCONVEDGE_RISING;
+    instance->adc_handle->Init.SamplingMode = ADC_SAMPLING_MODE_NORMAL;
+    instance->adc_handle->Init.DMAContinuousRequests = DISABLE;
+    instance->adc_handle->Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
+    instance->adc_handle->Init.OversamplingMode = DISABLE;
 
     if (HAL_ADC_Init(&g_hadc) != HAL_OK) {
         THROW(ERROR_HARDWARE_FAULT);
     }
 
-    // Configure ADC channel
+    // Configure the ADC channel
+    instance->adc_config = g_config;
     g_config.Channel = ADC_CHANNEL_0; // ADC1_IN0
     g_config.Rank = ADC_REGULAR_RANK_1;
     g_config.SamplingTime = ADC_SAMPLETIME_12CYCLES_5;
     g_config.SingleDiff = ADC_SINGLE_ENDED; // Single-ended input
     g_config.OffsetNumber = ADC_OFFSET_NONE;
     g_config.Offset = 0;
-    if (HAL_ADC_ConfigChannel(&g_hadc, &g_config) != HAL_OK) {
+    if (HAL_ADC_ConfigChannel(instance->adc_handle, &g_config) != HAL_OK) {
         THROW(ERROR_HARDWARE_FAULT);
     }
 
     // Calibration with error handling
     if (HAL_ADCEx_Calibration_Start(&g_hadc, ADC_SINGLE_ENDED) != HAL_OK) {
         THROW(ERROR_HARDWARE_FAULT);
     } // Calibration
+
+    // Set the ADC buffer and size
+    instance->adc_buffer_data = adc_buf;
+    instance->adc_buffer_size = sz;
+    instance->initialized = true;
 }
 
 /**
@@ -119,10 +184,24 @@ void ADC_LL_init(ADC_LL_TriggerSource adc_trigger_timer)
  */
 void ADC_LL_deinit(void)
 {
+    if (!g_adc_instance.initialized) {
+        THROW(ERROR_RESOURCE_UNAVAILABLE);
+        return;
+    }
+
+    ADCInstance *instance = &g_adc_instance;
+    // Stop the ADC conversion;
+    HAL_NVIC_DisableIRQ(ADC1_IRQn); // Disable ADC1 interrupt
+
     // Deinitialize the ADC peripheral
-    if (HAL_ADC_DeInit(&g_hadc) != HAL_OK) {
+    if (HAL_ADC_DeInit(instance->adc_handle) != HAL_OK) {
         THROW(ERROR_HARDWARE_FAULT);
     }
+
+    instance->adc_buffer_data = nullptr;
+    instance->adc_buffer_size = 0;
+    instance->adc_complete_callback = nullptr; // Clear the callback
+    instance->initialized = false;
 }
 
 /**
@@ -134,10 +213,15 @@ void ADC_LL_deinit(void)
  */
 void ADC_LL_start(void)
 {
-    // Start the ADC conversion
-    if (HAL_ADC_Start_IT(&g_hadc) != HAL_OK) {
+    __HAL_ADC_CLEAR_FLAG(&g_hadc, ADC_FLAG_OVR); // Clear any previous flags
+
+    if (HAL_ADC_Start_DMA(
+            &g_hadc,
+            (uint32_t *)g_adc_instance.adc_buffer_data,
+            g_adc_instance.adc_buffer_size
+        ) != HAL_OK) {
         THROW(ERROR_HARDWARE_FAULT);
-    }
+    } // Start ADC in DMA mode
 }
 
 /**
@@ -150,24 +234,38 @@ void ADC_LL_start(void)
 void ADC_LL_stop(void)
 {
     // Stop the ADC conversion
-    if (HAL_ADC_Stop_IT(&g_hadc) != HAL_OK) {
+    if (HAL_ADC_Stop_DMA(&g_hadc) != HAL_OK) {
         THROW(ERROR_HARDWARE_FAULT);
     }
 }
 
+/**
+ * @brief Sets the ADC complete callback.
+ *
+ * This function sets the user-defined callback that will be called when the
+ * ADC conversion is complete.
+ *
+ * @param callback Pointer to the callback function.
+ */
 void ADC_LL_set_complete_callback(ADC_LL_CompleteCallback callback)
 {
-    g_adc_complete_callback = callback; // Set the user-defined callback
+    g_adc_instance.adc_complete_callback =
+        callback; // Set the user-defined callback
 }
 
 void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
 {
     (void)hadc; // Suppress unused parameter warning
-    uint32_t value = HAL_ADC_GetValue(&g_hadc);
-    if (g_adc_complete_callback != nullptr) {
-        g_adc_complete_callback(value
+
+    if (g_adc_instance.adc_complete_callback != nullptr) {
+        g_adc_instance.adc_complete_callback(
         ); // Call the user-defined callback with the ADC value
     }
 }
 
 void ADC1_IRQHandler(void) { HAL_ADC_IRQHandler(&g_hadc); }
+
+void GPDMA1_Channel6_IRQHandler(void)
+{
+    HAL_DMA_IRQHandler(&g_hdma_adc); // Handle DMA interrupts
+}