Btukfyl

I'm working on the ADC , conversion triggered by timer2 , but there is no output. APB2 Timers clock is 80Mhz. Only 1 ADC channel. ADC clock is also 80Mhz. ADC conversion is triggered by 3.3us. Controller is STM32L452. Ignore Timer3.

Please let me know where I'M WRONG.

ADC+TIMER2+DMA

#define BUFFERSIZE   (50U)

static uint32_t adc_buf[BUFFERSIZE] = {0};





/* USER CODE BEGIN Includes */



/* USER CODE END Includes */



/* Private variables ---------------------------------------------------------*/



ADC_HandleTypeDef hadc1;



ADC_ChannelConfTypeDef sConfig;



DMA_HandleTypeDef hdma_adc1;



TIM_HandleTypeDef htim2;

TIM_HandleTypeDef htim3;



/* USER CODE BEGIN PV */

/* Private variables ---------------------------------------------------------*/



/* USER CODE END PV */



/* Private function prototypes -----------------------------------------------*/



void SystemClock_Config(void);



static void MX_GPIO_Init(void);



static void MX_DMA_Init(void);



static void MX_TIM3_Init(void);



static void MX_ADC1_Init(void);



static void MX_TIM2_Init(void);



void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);











/**

  * @brief  The application entry point.

  *

  * @retval None

  */

int main(void)

{

  /* USER CODE BEGIN 1 */



  /* USER CODE END 1 */



  /* MCU Configuration----------------------------------------------------------*/



  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */



  HAL_Init();



  /* USER CODE BEGIN Init */



  /* USER CODE END Init */



  /* Configure the system clock */



  SystemClock_Config();



  /* USER CODE BEGIN SysInit */



  /* USER CODE END SysInit */



  /* Initialize all configured peripherals */



  MX_GPIO_Init();





  MX_TIM3_Init();



  MX_ADC1_Init();



  MX_TIM2_Init();



  MX_DMA_Init();



  /* USER CODE BEGIN 2 */

 HAL_TIM_Base_Start(&htim2);





  /* USER CODE END 2 */





  HAL_ADC_Start_DMA(&hadc1, adc_buf, BUFFERSIZE);



  /* Infinite loop */

  /* USER CODE BEGIN WHILE */

  while (1)

  {



  /* USER CODE END WHILE */



  /* USER CODE BEGIN 3 */



  }

  /* USER CODE END 3 */



}



/**

  * @brief System Clock Configuration

  * @retval None

  */

void SystemClock_Config(void)

{





  RCC_OscInitTypeDef RCC_OscInitStruct;



  RCC_ClkInitTypeDef RCC_ClkInitStruct;



  RCC_PeriphCLKInitTypeDef PeriphClkInit;





    /**Initializes the CPU, AHB and APB busses clocks 

    */



RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;



  RCC_OscInitStruct.HSEState = RCC_HSE_ON;



  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;



  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;



  RCC_OscInitStruct.PLL.PLLM = 1;



  RCC_OscInitStruct.PLL.PLLN = 20;



  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7;



  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;



  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;



  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)

  {

    _Error_Handler(__FILE__, __LINE__);

  }



    /**Initializes the CPU, AHB and APB busses clocks 

    */





     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK

                                  |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;

      RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

      RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

      RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

      RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;



  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)

  {

    _Error_Handler(__FILE__, __LINE__);

  }



  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;

  PeriphClkInit.AdcClockSelection = RCC_ADCCLKSOURCE_PLLSAI1;

  PeriphClkInit.PLLSAI1.PLLSAI1Source = RCC_PLLSOURCE_HSE;

  PeriphClkInit.PLLSAI1.PLLSAI1M = 1;

  PeriphClkInit.PLLSAI1.PLLSAI1N = 16;

  PeriphClkInit.PLLSAI1.PLLSAI1P = RCC_PLLP_DIV7;

  PeriphClkInit.PLLSAI1.PLLSAI1Q = RCC_PLLQ_DIV2;

  PeriphClkInit.PLLSAI1.PLLSAI1R = RCC_PLLR_DIV2;

  PeriphClkInit.PLLSAI1.PLLSAI1ClockOut = RCC_PLLSAI1_ADC1CLK;

  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)

  {

    _Error_Handler(__FILE__, __LINE__);

  }



      HAL_RCC_MCOConfig(RCC_MCO1, RCC_MCO1SOURCE_SYSCLK, RCC_MCODIV_1);



        /**Configure the main internal regulator output voltage 

        */

      if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)

      {

        _Error_Handler(__FILE__, __LINE__);

      }



        /**Configure the Systick interrupt time 

        */

      HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);



        /**Configure the Systick 

        */

      HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);



      /* SysTick_IRQn interrupt configuration */

      HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

    }



    /* ADC1 init function */

    static void MX_ADC1_Init(void)

    {







        /**Common config 

        */

      hadc1.Instance = ADC1;

      hadc1.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;

      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;

      hadc1.Init.LowPowerAutoWait = DISABLE;

      hadc1.Init.ContinuousConvMode = DISABLE;

      hadc1.Init.NbrOfConversion = 1;

      hadc1.Init.DiscontinuousConvMode = 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;

      if (HAL_ADC_Init(&hadc1) != HAL_OK)

      {

        _Error_Handler(__FILE__, __LINE__);

      }







        /**Configure Regular Channel 

        */

      sConfig.Channel = ADC_CHANNEL_5;

      sConfig.Rank = ADC_REGULAR_RANK_1;

      sConfig.SamplingTime = ADC_SAMPLETIME_2CYCLES_5;

      sConfig.SingleDiff = ADC_SINGLE_ENDED;

      sConfig.OffsetNumber = ADC_OFFSET_NONE;

      sConfig.Offset = 0;

      if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)

      {

        _Error_Handler(__FILE__, __LINE__);

      }



    }



    /* TIM2 init function */

    static void MX_TIM2_Init(void)

    {



      TIM_ClockConfigTypeDef sClockSourceConfig;

      TIM_MasterConfigTypeDef sMasterConfig;



      __HAL_RCC_TIM2_CLK_ENABLE();;



      htim2.Instance = TIM2;

      htim2.Init.Prescaler = 0;

      htim2.Init.CounterMode = TIM_COUNTERMODE_UP;

      htim2.Init.Period = 267;

      htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

      htim2.Init.RepetitionCounter = 0;

    //  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

      if (HAL_TIM_Base_Init(&htim2) != HAL_OK)

      {

        _Error_Handler(__FILE__, __LINE__);

      }



      sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;

      if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)

      {

        _Error_Handler(__FILE__, __LINE__);

      }



      sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;

      sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

      if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)

      {

        _Error_Handler(__FILE__, __LINE__);

      }



    }



    /* TIM3 init function */

    static void MX_TIM3_Init(void)

    {



      TIM_ClockConfigTypeDef sClockSourceConfig;

      TIM_MasterConfigTypeDef sMasterConfig;

      TIM_OC_InitTypeDef sConfigOC;



      htim3.Instance = TIM3;

      htim3.Init.Prescaler = 0;

      htim3.Init.CounterMode = TIM_COUNTERMODE_UP;

      htim3.Init.Period = 2000;

      htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;



      if (HAL_TIM_Base_Init(&htim3) != HAL_OK)

      {

        _Error_Handler(__FILE__, __LINE__);

      }



      sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;

      if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)

      {

        _Error_Handler(__FILE__, __LINE__);

      }



      if (HAL_TIM_OC_Init(&htim3) != HAL_OK)

      {

        _Error_Handler(__FILE__, __LINE__);

      }



      sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;

      sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

      if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)

      {

        _Error_Handler(__FILE__, __LINE__);

      }



    //  sConfigOC.OCMode = TIM_OCMODE_TIMING;

    //  sConfigOC.Pulse = 0;

    //  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;

    //  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;

      if (HAL_TIM_OC_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)

      {

        _Error_Handler(__FILE__, __LINE__);

      }



      HAL_TIM_MspPostInit(&htim3);



    }



    /** 

      * Enable DMA controller clock

      */

    static void MX_DMA_Init(void) 

    {

      /* DMA controller clock enable */

      __HAL_RCC_DMA1_CLK_ENABLE();



      /* DMA interrupt init */

      /* DMA1_Channel1_IRQn interrupt configuration */

      HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);

      HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);



    }



    /** Configure pins as 

            * Analog 

            * Input 

            * Output

            * EVENT_OUT

            * EXTI

         PA8   ------> RCC_MCO

    */

    static void MX_GPIO_Init(void)

    {



      GPIO_InitTypeDef GPIO_InitStruct;



      /* GPIO Ports Clock Enable */

      __HAL_RCC_GPIOH_CLK_ENABLE();

      __HAL_RCC_GPIOA_CLK_ENABLE();

      __HAL_RCC_GPIOC_CLK_ENABLE();



      GPIO_InitStruct.Pin = DEBUG_LED_Pin;

       GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

       GPIO_InitStruct.Pull = GPIO_NOPULL;

       GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

       HAL_GPIO_Init(DEBUG_LED_GPIO_Port, &GPIO_InitStruct);



      /*Configure GPIO pin : PA8 */

      GPIO_InitStruct.Pin = GPIO_PIN_8;

      GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

      GPIO_InitStruct.Pull = GPIO_NOPULL;

      GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

      GPIO_InitStruct.Alternate = GPIO_AF0_MCO;

      HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);



      GPIO_InitStruct.Pin = GPIO_PIN_0;

      GPIO_InitStruct.Mode = GPIO_MODE_ANALOG_ADC_CONTROL;

      GPIO_InitStruct.Pull = GPIO_NOPULL;

      HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);





    }



    /* USER CODE BEGIN 4 */



    void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)

    {

        if (htim->Instance == htim3.Instance)

        {

            /* Toggle LED */

            HAL_GPIO_TogglePin(DEBUG_LED_GPIO_Port, DEBUG_LED_Pin);

        }

    }



    void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)

    {



      GPIO_InitTypeDef GPIO_InitStruct;

      if(hadc->Instance==ADC1)

      {

      /* USER CODE BEGIN ADC1_MspInit 0 */



      /* USER CODE END ADC1_MspInit 0 */

        /* Peripheral clock enable */

        __HAL_RCC_ADC_CLK_ENABLE();



        /**ADC1 GPIO Configuration    

        PA0     ------> ADC1_IN5 

        */

        GPIO_InitStruct.Pin = GPIO_PIN_0;

        GPIO_InitStruct.Mode = GPIO_MODE_ANALOG_ADC_CONTROL;

        GPIO_InitStruct.Pull = GPIO_NOPULL;

        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);



        /* ADC1 DMA Init */

        /* ADC1 Init */

        hdma_adc1.Instance = DMA1_Channel1;

        hdma_adc1.Init.Request = DMA_REQUEST_0;

        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_NORMAL;

        hdma_adc1.Init.Priority = DMA_PRIORITY_HIGH;



        if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)

        {

          _Error_Handler(__FILE__, __LINE__);

        }



        __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc1);



      /* USER CODE BEGIN ADC1_MspInit 1 */



      /* USER CODE END ADC1_MspInit 1 */

      }



    }

enter link description here

firstly htim2.Init.Prescaler = 0; try to give any number but 0 to prescaler to receive interrupt htim2.Init.Prescaler = 1 or 2 or else;
Secondly in your callback you are checking timer 2

   void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)

{

    if (htim->Instance == htim3.Instance)

    {

        /* Toggle LED */

        HAL_GPIO_TogglePin(DEBUG_LED_GPIO_Port, DEBUG_LED_Pin);

    }

}

I propose you to check timer2 because you are initializing the timer2 in your code which is //HAL_TIM_Base_Start(&htim2);

   void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)

{

    if (htim->Instance == TIM2)

    {

        /* Toggle LED */

        HAL_GPIO_TogglePin(DEBUG_LED_GPIO_Port, DEBUG_LED_Pin);

    }

}