Not able to change DMA2 Memory Address

[YashJ]

Dear Experts,

I need your assistance. I am attempting to change the memory address of DMA2 during runtime. I am streaming ADC data through UART. The ADC operates at 10MSPS using Timer1, and the tim1_up event triggers DMA2 Stream5 in circular mode. My buffer is data_buf[16384], and initially, I set the ADC to write data on the next half of data_buf[8192] to data_buf[16384].

My UART uses DMA2 Stream7 to transmit a full buffer from data_buf[0] to data_buf[16384]. Once the Half Transfer Complete Callback is received from the UART, I need to change the memory address and set it to the upper half of data_buf[0] to data_buf[8192]. This way, the ADC can write data on the upper half. Once the Transfer Complete Callback is received from the UART, I need to change the address and set it from data_buf[8192] to data_buf[16384].

However, I cannot change the address of the DMA2 Stream5 memory, even after disabling it by resetting bit 0 of the Stream Control Register.

 

/* USER CODE BEGIN Header */
/**
STM32F411CEU6
 ******************************************************************************
 * @file : main.c
 * @brief : Main program body
 ******************************************************************************
 * @attention
 *
 * Copyright (c) 2024 STMicroelectronics.
 * All rights reserved.
 *
 * This software is licensed under terms that can be found in the LICENSE file
 * in the root directory of this software component.
 * If no LICENSE file comes with this software, it is provided AS-IS.
 *
 ******************************************************************************
 */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define full_points			16384
#define half_points			8192

//#define full_buf_size		32768
//#define half_buf_size		16384
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
TIM_HandleTypeDef htim1;
DMA_HandleTypeDef hdma_tim1_up;

UART_HandleTypeDef huart1;
DMA_HandleTypeDef hdma_usart1_tx;

/* USER CODE BEGIN PV */
uint16_t data_buf[full_points] = { 0 };
uint8_t states = 0;

/* 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_USART1_UART_Init(void);
static void MX_TIM1_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
//void TxHalfCpltCallback(DMA_HandleTypeDef *huart){
//	GPIOB->ODR ^= 0x0001U;
//	hdma_tim1_up.Instance->CR &= ~(0x00000001U);
//	hdma_tim1_up.Instance->M0AR = (uint32_t)&data_buf;
//	hdma_tim1_up.Instance->CR |= (0x00000001U);
//}
//void TxCpltCallback(DMA_HandleTypeDef *huart){
//	GPIOB->ODR ^= 0x0001U;
////	hdma_tim1_up.Instance->CR &= ~(0x00000001U);
////	hdma_tim1_up.Instance->M0AR = (uint32_t)&data_buf[half_points];
////	hdma_tim1_up.Instance->CR |= (0x00000001U);
//}
void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart){
	GPIOB->ODR ^= 0x0001U;
	hdma_tim1_up.Instance->CR &= ~(0x00000001U);
	hdma_tim1_up.Instance->M0AR = (uint32_t)&data_buf[0];
	hdma_tim1_up.Instance->CR |= (0x00000001U);
}

//void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
//{
//	GPIOB->ODR ^= 0x0001U;
//	hdma_tim1_up.Instance->CR &= ~(0x00000001U);
//	hdma_tim1_up.Instance->M0AR = (uint32_t)&data_buf[8192];
//	hdma_tim1_up.Instance->CR |= (0x00000001U);
//}
/* USER CODE END 0 */

/**
 * @brief The application entry point.
 * @retval int
 */
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_DMA_Init();
 MX_USART1_UART_Init();
 MX_TIM1_Init();
 /* USER CODE BEGIN 2 */
 for(int i = 0;i<16384;i++){
	 data_buf[i] = i;
 }

 HAL_DMA_Start(&hdma_tim1_up, (uint32_t) &(GPIOA->IDR),(uint32_t) &data_buf[half_points], 8192); //Interrupt Ensure that data is transfered

 TIM1->DIER |= (1 << 8); // set UDE bit (update dma request enable)

 HAL_TIMEx_PWMN_Start(&htim1, TIM_CHANNEL_1);

 HAL_UART_Transmit_DMA(&huart1, (uint8_t*)data_buf,32768);
// hdma_usart1_tx.XferHalfCpltCallback = &TxHalfCpltCallback;
// hdma_usart1_tx.XferCpltCallback = &TxCpltCallback;

 /* USER CODE END 2 */

 /* 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 = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

 /** Configure the main internal regulator output voltage
 */
 __HAL_RCC_PWR_CLK_ENABLE();
 __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

 /** Initializes the RCC Oscillators according to the specified parameters
 * in the RCC_OscInitTypeDef structure.
 */
 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 = 12;
 RCC_OscInitStruct.PLL.PLLN = 96;
 RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
 RCC_OscInitStruct.PLL.PLLQ = 4;
 if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
 {
 Error_Handler();
 }

 /** Initializes the CPU, AHB and APB buses 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_DIV2;
 RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK)
 {
 Error_Handler();
 }
}

/**
 * @brief TIM1 Initialization Function
 * @param None
 * @retval None
 */
static void MX_TIM1_Init(void)
{

 /* USER CODE BEGIN TIM1_Init 0 */

 /* USER CODE END TIM1_Init 0 */

 TIM_ClockConfigTypeDef sClockSourceConfig = {0};
 TIM_MasterConfigTypeDef sMasterConfig = {0};
 TIM_OC_InitTypeDef sConfigOC = {0};
 TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};

 /* USER CODE BEGIN TIM1_Init 1 */

 /* USER CODE END TIM1_Init 1 */
 htim1.Instance = TIM1;
 htim1.Init.Prescaler = 0;
 htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
 htim1.Init.Period = 10-1;
 htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
 htim1.Init.RepetitionCounter = 0;
 htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
 if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
 {
 Error_Handler();
 }
 sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
 if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
 {
 Error_Handler();
 }
 sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
 sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
 if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sConfigOC.OCMode = TIM_OCMODE_PWM1;
 sConfigOC.Pulse = 5;
 sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
 sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
 sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;
 sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
 sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
 if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
 {
 Error_Handler();
 }
 sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
 sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
 sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
 sBreakDeadTimeConfig.DeadTime = 0;
 sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
 sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
 sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
 if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN TIM1_Init 2 */

 /* USER CODE END TIM1_Init 2 */
 HAL_TIM_MspPostInit(&htim1);

}

/**
 * @brief USART1 Initialization Function
 * @param None
 * @retval None
 */
static void MX_USART1_UART_Init(void)
{

 /* USER CODE BEGIN USART1_Init 0 */

 /* USER CODE END USART1_Init 0 */

 /* USER CODE BEGIN USART1_Init 1 */

 /* USER CODE END USART1_Init 1 */
 huart1.Instance = USART1;
 huart1.Init.BaudRate = 2000000;
 huart1.Init.WordLength = UART_WORDLENGTH_8B;
 huart1.Init.StopBits = UART_STOPBITS_1;
 huart1.Init.Parity = UART_PARITY_NONE;
 huart1.Init.Mode = UART_MODE_TX_RX;
 huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
 huart1.Init.OverSampling = UART_OVERSAMPLING_16;
 if (HAL_UART_Init(&huart1) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN USART1_Init 2 */

 /* USER CODE END USART1_Init 2 */

}

/**
 * Enable DMA controller clock
 */
static void MX_DMA_Init(void)
{

 /* DMA controller clock enable */
 __HAL_RCC_DMA2_CLK_ENABLE();

 /* DMA interrupt init */
 /* DMA2_Stream7_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 1, 0);
 HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);

}

/**
 * @brief GPIO Initialization Function
 * @param None
 * @retval None
 */
static void MX_GPIO_Init(void)
{
 GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */

 /* GPIO Ports Clock Enable */
 __HAL_RCC_GPIOH_CLK_ENABLE();
 __HAL_RCC_GPIOA_CLK_ENABLE();
 __HAL_RCC_GPIOB_CLK_ENABLE();

 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);

 /*Configure GPIO pins : PA0 PA1 PA2 PA3
 PA4 PA5 PA6 PA7
 PA8 PA9 PA10 PA11
 PA12 */
 GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3
 |GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7
 |GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11
 |GPIO_PIN_12;
 GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
 GPIO_InitStruct.Pull = GPIO_PULLDOWN;
 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

 /*Configure GPIO pin : PB0 */
 GPIO_InitStruct.Pin = GPIO_PIN_0;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_PULLDOWN;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
 * @brief This function is executed in case of error occurrence.
 * @retval None
 */
void Error_Handler(void)
{
 /* USER CODE BEGIN Error_Handler_Debug */
 /* User can add his own implementation to report the HAL error return state */
 __disable_irq();
 while (1)
 {
 }
 /* USER CODE END Error_Handler_Debug */
}

#ifdef USE_FULL_ASSERT
/**
 * @brief Reports the name of the source file and the source line number
 * where the assert_param error has occurred.
 * @param file: pointer to the source file name
 * @param line: assert_param error line source number
 * @retval None
 */
void assert_failed(uint8_t *file, uint32_t 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\r\n", file, line) */
 /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

 

 

@TDK  @Pavel A. 

[gbm]

With HAL, you need to check which stream's HalfComplete interrupt you are handling.

[YashJ]

Hi,

So I am using just 1 UART which is UART1. I don't think that it need to be check which uart is calling the callback function.

[AScha.3]

Hi,

>I set the ADC to write data on the next half

Why ??? If you set it to circular mode, it will do this anyway by itself . 

And you get the callbacks , when first /or second half buffer is ready/filled.

Here you copy or do whatever you want to do with the data - just "in time" , before next callback coming;

here 8K/10M  -> about 800us .

btw What you make ? a mini DSO ?

And what you do with the data (in 10ms whole ram is full ...) ?

[YashJ]

Hi,

So I am using external ADC connected on GPIO Port A and clock is 10MHz generated using Timer1 PWM. 

The ADC is much faster than the UART which is working at 2M Baud rate.

12-bit ADC at 10MSPS gives ~19MByte/S.

UART at 2MBit/s gives ~195KByte/S.

So, UART is 100 times slower than ADC.

The UART will transmit the upper half buffer mean while the ADC is writing data on lower half buffer in circular mode, ADC will overwrite the lower buffer ~100 times, than after half transmit callback from UART I am changing address of DMA2 Stream5 to fill upper half buffer in circular mode until the lower half is being transmitted. As length is the half buffer points 8192. So if I change the address to start of the buffer in circular mode it will overwrite the upper half.

HAL_DMA_Start(&hdma_tim1_up, (uint32_t) &(GPIOA->IDR),(uint32_t) &data_buf[half_points], 8192);

[AScha.3]

Hi,

ok, so you do a 8K "shot" and then transfer data.

Why external ADC ?   12bit ADC is on chip and if need higher speed you could use a F303 , has 5 Msps ADCs , 2 in dual mode give 10 Msps .

+

About DMA : for just one shot you could start DMA in normal mode , gives you the array full of data and after transmission you start next shot . 

 

[LCE]

What do you actually want to do?

1st half of buffer: timer capture data,

2nd half: ADC data ? ADC data within same time window as timer input capture?

 

 > UART / ADC at 10MSPS 

ADC at 10MSPS with 10 bit resolution -> 100 Mbit/s

This will not work for continuous / "CIRCULAR DMA" streaming. The UART's limit is 1/16 of the clock. And it's BIT / s.

So you can / must split it anyway, like use a timer buffer, another for ADC, after both have finished, transfer data via UART, when this has finished, restart timer / ADC.

[LCE]

Something like this... (keep in in bit/s, then it's 120 Mbit/s vs 2 Mbit/s).

Anyway, again: what is it you actually want to achieve?

Do you need the timer capture values from within the same time frame as the ADC values?

Is UART your only option for data transfer? At this data rate only USB 2.0 High Speed is the only option, I don't know if the F4 can do that.

 

[YashJ]

what is it you actually want to achieve?

For now, I want to change the DMA2 Stream5 memory address. As mentioned in the reference manual to change the content in the DMA_SxM0AR resistor (the stream is disabled (bit EN= '0' in the DMA_SxCR register). Even after clearing EN bit I couldn't change the value. 

Do you need the timer to capture values within the same time frame as the ADC values?

Yes, but I didn't find any way to do it with UART at a 2M baud rate. only the way is to reduce the sampling frequency, which I don't want to do.

Is UART your only option for data transfer?

No. USB could be used but need to write driver for that.

Only USB 2.0 High Speed 480Mbit/s could be used. STM32F407 supports external USB with ULPL protocol. I will try this with USB3343 chip.