Use DMA

application.fam

@@ -12,7 +12,7 @@ App(
         Lib(name="adc",
             fap_include_paths=["inc"],
             sources=[
-                "stm32wbxx_hal_adc.c", "stm32wbxx_hal_adc_ex.c", "stm32wbxx_hal_rcc_ex.c", "stm32wbxx_hal_gpio.c", "stm32wbxx_hal_pwr.c", "stm32wbxx_hal.c"
+                "stm32wbxx_hal_adc.c", "stm32wbxx_hal_adc_ex.c", "stm32wbxx_hal_rcc_ex.c", "stm32wbxx_hal_gpio.c", "stm32wbxx_hal_pwr.c", "stm32wbxx_hal.c", "stm32wbxx_hal_tim.c", "stm32wbxx_hal_tim_ex.c", "stm32wbxx_hal_cortex.c", "stm32wbxx_hal_dma.c", "stm32wbxx_hal_rcc.c"
             ],
     )]
 )

lib/adc/inc/stm32wbxx_hal_conf.h

@@ -54,7 +54,7 @@
 /*#define HAL_SMBUS_MODULE_ENABLED   */
 /*#define HAL_SMARTCARD_MODULE_ENABLED   */
 /*#define HAL_SPI_MODULE_ENABLED   */
-/*#define HAL_TIM_MODULE_ENABLED   */
+#define HAL_TIM_MODULE_ENABLED
 /*#define HAL_TSC_MODULE_ENABLED   */
 /*#define HAL_UART_MODULE_ENABLED   */
 /*#define HAL_USART_MODULE_ENABLED   */

lib/adc/inc/stm32wbxx_hal_tim.h

@@ -0,0 +1 @@
+../../../../../lib/STM32CubeWB/Drivers/STM32WBxx_HAL_Driver/Inc/stm32wbxx_hal_tim.h

lib/adc/stm32wbxx_hal_cortex.c

@@ -0,0 +1 @@
+../../../../lib/STM32CubeWB/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_hal_cortex.c

lib/adc/stm32wbxx_hal_dma.c

@@ -0,0 +1 @@
+../../../../lib/STM32CubeWB/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_hal_dma.c

lib/adc/stm32wbxx_hal_rcc.c

@@ -0,0 +1 @@
+../../../../lib/STM32CubeWB/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_hal_rcc.c

lib/adc/stm32wbxx_hal_tim.c

@@ -0,0 +1 @@
+../../../../lib/STM32CubeWB/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_hal_tim.c

lib/adc/stm32wbxx_hal_tim_ex.c

@@ -0,0 +1 @@
+../../../../lib/STM32CubeWB/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_hal_tim_ex.c

scope.c

@@ -1,33 +1,25 @@
 #include <furi.h>
 #include <furi_hal.h>
 #include <furi_hal_resources.h>
-
 #include <gui/gui.h>
 #include <input/input.h>
 
 #include "stm32wbxx_hal.h"
+#include "stm32wbxx_hal_tim.h"
 #include "stm32wbxx_nucleo.h"
-
-#include "stm32wbxx_ll_adc.h"
-#include "stm32wbxx_ll_dma.h"
-
+#include "stm32wbxx_hal_adc.h"
 #include "scope_icons.h"
 
 #define DIGITAL_SCALE_12BITS             ((uint32_t) 0xFFF)
-
+#define ADC_CONVERTED_DATA_BUFFER_SIZE   ((uint32_t)  64)
 #define VAR_CONVERTED_DATA_INIT_VALUE    (DIGITAL_SCALE_12BITS + 1)
 #define VAR_CONVERTED_DATA_INIT_VALUE_16BITS    (0xFFFF + 1U)
 #define __ADC_CALC_DATA_VOLTAGE(__VREFANALOG_VOLTAGE__, __ADC_DATA__)       \
   ((__ADC_DATA__) * (__VREFANALOG_VOLTAGE__) / DIGITAL_SCALE_12BITS)
 #define VDDA_APPLI                       ((uint32_t)3300)
 
-ADC_HandleTypeDef hadc1 = { 0 };
-
-/* Variables for ADC conversion data */
-__IO uint16_t uhADCxConvertedData = VAR_CONVERTED_DATA_INIT_VALUE;      /* ADC group regular conversion data */
-
-/* Variables for ADC conversion data computation to physical values */
-uint16_t uhADCxConvertedData_Voltage_mVolt = 0; /* Value of voltage calculated from ADC conversion data (unit: mV) */
+#include <stdlib.h>
+#include <string.h>
 
 void Error_Handler()
 {
@@ -35,62 +27,204 @@ void Error_Handler()
     }
 }
 
-static void MX_ADC1_Init(void)
+uint16_t i = 0;
+
+static ADC_HandleTypeDef hadc1;
+static DMA_HandleTypeDef hdma_adc1;
+static TIM_HandleTypeDef htim2;
+
+__IO uint16_t aADCxConvertedData[ADC_CONVERTED_DATA_BUFFER_SIZE];       /* ADC group regular conversion data (array of data) */
+__IO uint16_t aADCxConvertedData_Voltage_mVolt[ADC_CONVERTED_DATA_BUFFER_SIZE]; /* Value of voltage calculated from ADC conversion data (unit: mV) (array of data) */
+__IO uint8_t ubDmaTransferStatus = 2;   /* Variable set into DMA interruption callback */
+
+void HAL_MspInit(void)
 {
-    hadc1.Instance = ADC1;
-    RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = { 0 };
-    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_ADC;
-    PeriphClkInitStruct.AdcClockSelection = RCC_ADCCLKSOURCE_PLL;
-    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK) {
-        Error_Handler();
+}
+
+void HAL_ADC_MspInit(ADC_HandleTypeDef * hadc)
+{
+    GPIO_InitTypeDef GPIO_InitStruct = { 0 };
+    if (hadc->Instance == ADC1) {
+        __HAL_RCC_ADC_CLK_ENABLE();
+        __HAL_RCC_GPIOC_CLK_ENABLE();
+        GPIO_InitStruct.Pin = GPIO_PIN_0;
+        GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+        GPIO_InitStruct.Pull = GPIO_NOPULL;
+        HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
+
+        hdma_adc1.Instance = DMA1_Channel1;
+        hdma_adc1.Init.Request = DMA_REQUEST_ADC1;
+        hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
+        hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
+        hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
+        hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
+        hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
+        hdma_adc1.Init.Mode = DMA_CIRCULAR;
+        hdma_adc1.Init.Priority = DMA_PRIORITY_LOW;
+        if (HAL_DMA_Init(&hdma_adc1) != HAL_OK) {
+            Error_Handler();
+        }
+
+        __HAL_LINKDMA(hadc, DMA_Handle, hdma_adc1);
+
+        HAL_NVIC_SetPriority(ADC1_IRQn, 15, 0);
+        HAL_NVIC_EnableIRQ(ADC1_IRQn);
     }
+}
 
-    /* Peripheral clock enable */
-    // __HAL_RCC_ADC_CLK_ENABLE();
+void HAL_ADC_MspDeInit(ADC_HandleTypeDef * hadc)
+{
+    if (hadc->Instance == ADC1) {
+        __HAL_RCC_ADC_CLK_DISABLE();
+        HAL_GPIO_DeInit(GPIOC, GPIO_PIN_0);
+        HAL_DMA_DeInit(hadc->DMA_Handle);
+        HAL_NVIC_DisableIRQ(ADC1_IRQn);
+    }
+}
 
-    //HAL_Init();
-    //SystemClock_Config();
-    __HAL_RCC_ADC_CLK_ENABLE();
+void HAL_TIM_Base_MspInit(TIM_HandleTypeDef * htim_base)
+{
+    if (htim_base->Instance == TIM2) {
+        __HAL_RCC_TIM2_CLK_ENABLE();
+        HAL_NVIC_SetPriority(TIM2_IRQn, 15, 0);
+        HAL_NVIC_EnableIRQ(TIM2_IRQn);
+    }
+}
 
-    __HAL_RCC_GPIOA_CLK_ENABLE();
-    __HAL_RCC_GPIOB_CLK_ENABLE();
-    __HAL_RCC_GPIOC_CLK_ENABLE();
-    // __HAL_RCC_ADC_FORCE_RESET();
-    //       __HAL_RCC_ADC_RELEASE_RESET();
-    //furi_hal_gpio_init_ex(&gpio_ext_pc0, GpioModeAnalog, GpioPullNo, GpioSpeedVeryHigh, GpioAltFnUnused);
+void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef * htim_base)
+{
+    if (htim_base->Instance == TIM2) {
+        __HAL_RCC_TIM2_CLK_DISABLE();
+        HAL_NVIC_DisableIRQ(TIM2_IRQn);
+    }
+}
+
+void DMA1_Channel1_IRQHandler(void)
+{
+    HAL_DMA_IRQHandler(&hdma_adc1);
+}
+
+void ADC1_IRQHandler(void)
+{
+    HAL_ADC_IRQHandler(&hadc1);
+}
 
-    GPIO_InitTypeDef GPIO_initStructre = { 0, 0, 0, 0, 0 };
-    GPIO_initStructre.Pin = GPIO_PIN_0; // Provide input to channel 10 of ADC i.e GPIO Pin 0 of Port C
-    GPIO_initStructre.Mode = GPIO_MODE_ANALOG;  //GPIO Pin as analog Mode
-    GPIO_initStructre.Pull = GPIO_NOPULL;
-    HAL_GPIO_Init(GPIOC, &GPIO_initStructre);   // GPIO Initialization
+void TIM2_IRQHandler(void)
+{
+    HAL_TIM_IRQHandler(&htim2);
+}
 
+static void MX_ADC1_Init(void)
+{
+    ADC_ChannelConfTypeDef sConfig = { 0 };
+    hadc1.Instance = ADC1;
     hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
     hadc1.Init.Resolution = ADC_RESOLUTION_12B;
     hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
     hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
-    hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;      //ADC_EOC_SEQ_CONV ; //ADC_EOC_SINGLE_CONV;
+    hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
     hadc1.Init.LowPowerAutoWait = DISABLE;
     hadc1.Init.ContinuousConvMode = DISABLE;
-    //hadc1.Init.ContinuousConvMode = ENABLE;
     hadc1.Init.NbrOfConversion = 1;
     hadc1.Init.DiscontinuousConvMode = DISABLE;
-    hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
-    hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
-    hadc1.Init.DMAContinuousRequests = DISABLE;
+    hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIG_T2_TRGO;
+    hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
+    hadc1.Init.DMAContinuousRequests = ENABLE;
     hadc1.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
     hadc1.Init.OversamplingMode = DISABLE;
-    /*
-       hadc1.Init.Oversampling.Ratio = ADC_OVERSAMPLING_RATIO_16;
-       hadc1.Init.Oversampling.RightBitShift = ADC_RIGHTBITSHIFT_4;
-       hadc1.Init.Oversampling.TriggeredMode = ADC_TRIGGEREDMODE_SINGLE_TRIGGER;
-       hadc1.Init.Oversampling.OversamplingStopReset = ADC_REGOVERSAMPLING_CONTINUED_MODE;
-     */
-
     if (HAL_ADC_Init(&hadc1) != HAL_OK) {
         Error_Handler();
     }
 
+    sConfig.Channel = ADC_CHANNEL_1;
+    sConfig.Rank = ADC_REGULAR_RANK_1;
+    sConfig.SamplingTime = ADC_SAMPLETIME_2CYCLE_5;     ////ADC_SAMPLETIME_640CYCLES_5;
+    sConfig.SingleDiff = ADC_SINGLE_ENDED;
+    sConfig.OffsetNumber = ADC_OFFSET_NONE;
+    sConfig.Offset = 0;
+    if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
+        Error_Handler();
+    }
+}
+
+static void MX_TIM2_Init(void)
+{
+
+    TIM_ClockConfigTypeDef sClockSourceConfig = { 0 };
+    TIM_MasterConfigTypeDef sMasterConfig = { 0 };
+    htim2.Instance = TIM2;
+    htim2.Init.Prescaler = 1;
+    htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
+    htim2.Init.Period = 4194304;        //39999;
+    htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
+    htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
+    if (HAL_TIM_Base_Init(&htim2) != HAL_OK) {
+        Error_Handler();
+    }
+    sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
+    if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK) {
+        Error_Handler();
+    }
+    sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
+    sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
+    if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) !=
+        HAL_OK) {
+        Error_Handler();
+    }
+}
+
+static void MX_DMA_Init(void)
+{
+
+    __HAL_RCC_DMAMUX1_CLK_ENABLE();
+    __HAL_RCC_DMA1_CLK_ENABLE();
+    HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 15, 0);
+    HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
+
+}
+
+static void MX_GPIO_Init(void)
+{
+
+    __HAL_RCC_GPIOC_CLK_ENABLE();
+
+}
+
+void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef * hadc)
+{
+    UNUSED(hadc);
+    uint32_t tmp_index = 0;
+
+    for (tmp_index = (ADC_CONVERTED_DATA_BUFFER_SIZE / 2);
+         tmp_index < ADC_CONVERTED_DATA_BUFFER_SIZE; tmp_index++) {
+        aADCxConvertedData_Voltage_mVolt[tmp_index] =
+            __ADC_CALC_DATA_VOLTAGE(VDDA_APPLI,
+                                    aADCxConvertedData[tmp_index]);
+    }
+
+
+    ubDmaTransferStatus = 1;
+}
+
+void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef * hadc)
+{
+    UNUSED(hadc);
+    uint32_t tmp_index = 0;
+
+    for (tmp_index = 0; tmp_index < (ADC_CONVERTED_DATA_BUFFER_SIZE / 2);
+         tmp_index++) {
+        aADCxConvertedData_Voltage_mVolt[tmp_index] =
+            __ADC_CALC_DATA_VOLTAGE(VDDA_APPLI,
+                                    aADCxConvertedData[tmp_index]);
+    }
+
+    ubDmaTransferStatus = 0;
+}
+
+void HAL_ADC_ErrorCallback(ADC_HandleTypeDef * hadc)
+{
+    UNUSED(hadc);
+    Error_Handler();
 }
 
 typedef struct {
@@ -99,79 +233,77 @@ typedef struct {
 
 uint16_t val1;
 
-ADC_HandleTypeDef hadc1;
-
 static ImagePosition image_position = {.x = 0,.y = 0 };
 
 void assert_failed(uint8_t * file, uint32_t line)
 {
     UNUSED(file);
     UNUSED(line);
-    /* USER CODE BEGIN 6 */
-
-    /* User can add his own implementation to report the file name and line number,
-       ex: printf("Wrong parameters value: file %s on line %d", file, line) */
-
-    /* Infinite loop */
     while (1) {
     }
-    /* USER CODE END 6 */
 }
 
 // Screen is 128x64 px
 static void app_draw_callback(Canvas * canvas, void *ctx)
 {
     UNUSED(ctx);
-
-    //canvas_clear(canvas);
-    //canvas_draw_icon(canvas, image_position.x % 128, image_position.y % 64, &I_dolphin_71x25);
-    //char *hello = "hello";
     char buf[50];
     snprintf(buf, 50, "%d", val1);
     canvas_draw_str(canvas, 10, 10, buf);
     //canvas_draw_dot(canvas, image_position.x % 128, image_position.y % 64);
     canvas_draw_line(canvas, 0, 0, 0, 63);
     canvas_draw_line(canvas, 0, 63, 128, 63);
-
 }
 
 static void app_input_callback(InputEvent * input_event, void *ctx)
 {
     furi_assert(ctx);
-
     FuriMessageQueue *event_queue = ctx;
     furi_message_queue_put(event_queue, input_event, FuriWaitForever);
 }
 
+
 int32_t scope_main(void *p)
 {
     UNUSED(p);
-    //UNUSED(MX_DMA_Init);
-    //UNUSED(MX_GPIO_Init);
+    HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
     FuriMessageQueue *event_queue =
         furi_message_queue_alloc(8, sizeof(InputEvent));
-    /*
-       HAL_SYSCFG_VREFBUF_VoltageScalingConfig(SYSCFG_VREFBUF_VOLTAGE_SCALE1);
-       HAL_SYSCFG_EnableVREFBUF();
-     */
-    VREFBUF->CSR |= VREFBUF_CSR_ENVR;
 
-    VREFBUF->CSR &= ~VREFBUF_CSR_HIZ;
+    uint32_t tmp_index_adc_converted_data = 0;
+    MX_GPIO_Init();
+    MX_DMA_Init();
+    MX_TIM2_Init();
 
-    VREFBUF->CSR |= VREFBUF_CSR_VRS;
 
+    VREFBUF->CSR |= VREFBUF_CSR_ENVR;
+    VREFBUF->CSR &= ~VREFBUF_CSR_HIZ;
+    VREFBUF->CSR |= VREFBUF_CSR_VRS;
     while (!(VREFBUF->CSR & VREFBUF_CSR_VRR)) {
     };
 
     MX_ADC1_Init();
+    for (tmp_index_adc_converted_data = 0;
+         tmp_index_adc_converted_data < ADC_CONVERTED_DATA_BUFFER_SIZE;
+         tmp_index_adc_converted_data++) {
+        aADCxConvertedData[tmp_index_adc_converted_data] =
+            VAR_CONVERTED_DATA_INIT_VALUE;
+    }
 
-    //Initialize LED on board 
     if (HAL_ADCEx_Calibration_Start(&hadc1, ADC_SINGLE_ENDED) != HAL_OK) {
         Error_Handler();
     }
 
-    int i = 0;
-    // Configure view port
+    if (HAL_TIM_Base_Start(&htim2) != HAL_OK) {
+        Error_Handler();
+    }
+
+    if (HAL_ADC_Start_DMA(&hadc1,
+                          (uint32_t *) aADCxConvertedData,
+                          ADC_CONVERTED_DATA_BUFFER_SIZE) != HAL_OK) {
+        Error_Handler();
+    }
+
     ViewPort *view_port = view_port_alloc();
     view_port_draw_callback_set(view_port, app_draw_callback, view_port);
     view_port_input_callback_set(view_port, app_input_callback,
@@ -180,12 +312,11 @@ int32_t scope_main(void *p)
     // Register view port in GUI
     Gui *gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
-
     InputEvent event;
-
     bool running = true;
+    
     while (running) {
-        if (furi_message_queue_get(event_queue, &event, 100) ==
+        if (furi_message_queue_get(event_queue, &event, 102) ==
             FuriStatusOk) {
             if ((event.type == InputTypePress)
                 || (event.type == InputTypeRepeat)) {
@@ -209,46 +340,7 @@ int32_t scope_main(void *p)
             }
         }
 
-        ADC_ChannelConfTypeDef sConfig = { 0 };
-        sConfig.Channel = ADC_CHANNEL_1;
-        sConfig.Rank = ADC_REGULAR_RANK_1;
-        sConfig.SamplingTime = ADC_SAMPLETIME_640CYCLES_5;      ////ADC_SAMPLETIME_640CYCLES_5;
-        sConfig.SingleDiff = ADC_SINGLE_ENDED;
-        sConfig.OffsetNumber = ADC_OFFSET_NONE;
-        sConfig.Offset = 0;
-
-        if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
-            Error_Handler();
-        }
-
-        /* Start ADC group regular conversion */
-        if (HAL_ADC_Start(&hadc1) != HAL_OK) {
-            /* ADC conversion start error */
-            Error_Handler();
-        }
-
-        /* Wait till conversion is done */
-        if (HAL_ADC_PollForConversion(&hadc1, 1000) != HAL_OK) {
-            /* End Of Conversion flag not set on time */
-            Error_Handler();
-        } else {
-            /* Retrieve ADC conversion data */
-            uhADCxConvertedData = HAL_ADC_GetValue(&hadc1);
-
-            /* Computation of ADC conversions raw data to physical values           */
-            /* using helper macro.                                                  */
-            uhADCxConvertedData_Voltage_mVolt =
-                __ADC_CALC_DATA_VOLTAGE(VDDA_APPLI, uhADCxConvertedData);
-            i++;
-            val1 = uhADCxConvertedData_Voltage_mVolt;   // + i;
-        }
-
-        /* Start ADC group regular conversion */
-        if (HAL_ADC_Stop(&hadc1) != HAL_OK) {
-            /* ADC conversion start error */
-            Error_Handler();
-        }
-
+        val1 = aADCxConvertedData[0];
         view_port_update(view_port);
     }