How To Achieve Fast Data Write On GPIO Port With The Fixed Frequency Between 5MHz to 10MHz?

[YashJ]

Dear Experts,

I need your help, I am interfacing 16-bit DAC LTC1668 50MHz with STM32F411CCU6. 

I have used Timer 4 as 1MHz CLK for DAC, on Half Pulse Complete interrupt I update the GPIO Port (Port A A0-A7 are D0-D7, Port B B0-B7 are D8-D15). But Facing problem as the Data on the ports take 3 to 4 CLK cycles to change. As I lower the CLK to 275KHz the Data on ports changes before the next cycle. How can I make it change before the next cycle in higher frequencies say 5MHz to 10MHz. 

For Sinewave Data points are generated through python program, further these data points are being transfered through USB, But now I am stuck here.

I have attached RCC CLK configs, Pin configs, Timer Configs. I can share more details if needed. 

Here is the code for Timer Interrut Routine:-

 

 

 

const uint16_t pypoints[2750] = {32768,33516,34264,35012,................30523,31271,32019};
int k = 0;
void HAL_TIM_PWM_PulseFinishedHalfCpltCallback(TIM_HandleTypeDef *htim) {
	GPIOA->ODR = (uint32_t)(pypoints[k] & 0xFF);//LSB
	GPIOB->ODR = (uint32_t)((pypoints[k] >> 8 ) & 0xFF);//MSB
	k++;
	if(k >= 2750)
		k = 0;
}

 

 

 

[TDK]

Using DMA is going to be the best way to achieve this. You can set up two channels of a timer to trigger at the same time and transfer a byte into GPIOx->ODR.

Using interrupts at speeds of 1MHz+ is generally a nonstarter, especially with HAL.

[YashJ]

I have tried DMA1 config as Memory to Periperal with Timer 4 config as PWM gen using its Update Event to transfer data byte to GPIO Port A but that didin't worked. I debuged and found that Timer PWM was working but it doesn't trigger DMA or may be some problem with DMA1.

Than, I tried DMA2 config as Memory to Periperal with Timer 1 as PWM gen using its Update Event to transfer data half word to GPIO Port A used complimentary output as DAC CLK and that worked. But unable to go more than 1MHz (Ticks = 96) as I go lower (Ticks = 72) I didn't even got PWM Output.

Here is the code:-

 

int main(void)
{
 HAL_Init();

 SystemClock_Config();

 /* Initialize all configured peripherals */
 MX_GPIO_Init();
 MX_DMA_Init();
 MX_TIM1_Init();
 /* USER CODE BEGIN 2 */

 HAL_DMA_Start_IT(&hdma_tim1_up, (uint32_t)pypoints, (uint32_t)&(GPIOA->ODR), 100);//Interrupt Ensure that data is transfered
 HAL_TIM_Base_Start_IT(&htim1);

 HAL_TIM_PWM_Start_IT(&htim1, TIM_CHANNEL_1);
 HAL_TIMEx_PWMN_Start_IT(&htim1, TIM_CHANNEL_1);

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

 /* USER CODE BEGIN WHILE */
 while (1)
 {
 /* USER CODE END WHILE */

 /* USER CODE BEGIN 3 */
 }
 /* USER CODE END 3 */
}

 

[Tesla DeLorean]

You're not going to be able to interrupt at 1 MHz (1us) rates. Several hundred KHz perhaps if that's the only thing you expect the MCU to do.

You can use DMA to feed registers, or output to GPIO, but writing to multiple GPIO banks its going to be difficult and skewed. Singular bank, into the MHz

For WIDE output you might need to consider a device with F(S)MC external bussing, For signals at high wire speeds you should perhaps consider other methods, say using FPGA/CPLD, or pattern buffers in external RAMs or FIFO buffers.

New STM32 models have a Parallel Output method / peripheral.

[Zaher]

Could you please name that peripheral and one or more device/series that implements it. I'm doing a lot of parallel and CPLD/FPGA is not an option for me yet. It would be great if the peripheral you're talking about behaves like the GPIF in another silicon. While GPIF was quite a feasible solution and an alternative to an FPGA/CPLD for this particular task, it was overlooked for a number of reasons.

An STM32 with a parallel peripheral that can achieve speed very close to hardware (up to 100 Mhz for GPIF) and with DMACK and DREQ mechanism, would absolutely fill the gap and deficiencies on previous lines.

 

[Uwe Bonnes]

Look at devices with F(S)MC and look in the most recent families. STM32H7S comes to  ind. However I doubt that you can reach 100 MSample continous.

[TDK]

There's code here that does this on the F4 series:

https://community.st.com/t5/stm32-mcus-products/tim1-dma-driven-gpio-transmit-speed-limit/m-p/221798

 

[YashJ]

Thanks for your reply.

I am using STM32F411CEU6 and configured the TIM1_CH1 to trigger DMA2 to transmit data through GPIO. The TIM1 is just generating a PWM signal for the output clock of 10MHz. I have put all pins in GPIOA so I can use a half-word data width on PSIZE and MSIZE data width is a byte with FIFO Enabled (Full Threshold).

/* 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_buf_size			32768
#define half_buf_size			full_buf_size/2
/* USER CODE END PD */

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

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
TIM_HandleTypeDef htim1;
DMA_HandleTypeDef hdma_tim1_up;
/* USER CODE BEGIN PV */

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

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uint8_t data_buf[full_buf_size] ={0};//LSB MSB
/* 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_TIM1_Init();
 /* USER CODE BEGIN 2 */
 for(int i = 0; i < full_buf_size; i++)
 {
 	 data_buf[i] = 0xFF;
 	 i++;
 	 data_buf[i] = 0xFF;
 	 i++;
 	 data_buf[i] = 0x00;
 	 i++;
 	 data_buf[i] = 0x00;
 }

 if (HAL_DMA_Start(&hdma_tim1_up, (uint32_t)data_buf, (uint32_t)&(GPIOA->ODR), half_buf_size) != HAL_OK)
 {
 Error_Handler();
 }

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

 HAL_TIMEx_PWMN_Start(&htim1, TIM_CHANNEL_1);

 HAL_TIM_Base_Start(&htim1);

 /* 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);

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

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

}

/**
 * @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(GPIOA, D0_Pin|D1_Pin|D2_Pin|D3_Pin
 |D4_Pin|D5_Pin|D6_Pin|D7_Pin
 |D8_Pin|D9_Pin|D10_Pin|D11_Pin
 |D12_Pin|D13_Pin|D14_Pin|D15_Pin, GPIO_PIN_RESET);

 /*Configure GPIO pins : D0_Pin D1_Pin D2_Pin D3_Pin
 D4_Pin D5_Pin D6_Pin D7_Pin
 D8_Pin D9_Pin D10_Pin D11_Pin
 D12_Pin D13_Pin D14_Pin D15_Pin */
 GPIO_InitStruct.Pin = D0_Pin|D1_Pin|D2_Pin|D3_Pin
 |D4_Pin|D5_Pin|D6_Pin|D7_Pin
 |D8_Pin|D9_Pin|D10_Pin|D11_Pin
 |D12_Pin|D13_Pin|D14_Pin|D15_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_PULLDOWN;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 HAL_GPIO_Init(GPIOA, &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 */
}

 

[Zaher]

Well, 100 MS/s is not a requirement at all. I was just referring to what 'GPIF' was capable of in another silicon. However, the behavior of the interface and how it's implemented is what concerns me the most. Aside from DMAMUX and the many other options to route/generate requests, I didn't see anything about that "parallel peripheral". FMC in H7 seems pretty much the same as in the F4 line. I will take a look at the RM and see. Probably CubeMX doesn't reveal much.

[Uwe Bonnes]

I think STM32H7S has some advances and improvements in IP. Have also a look at that part.