DMA Mem to peripheral inconsistent output

[samsamm777]

I have a timer + dma which outputs a signal for addressable LEDS. The code calls the PWM Start function on a crude timer loop for testing purposes.

The first time the DMS starts, its perfect, and the output is correct and as expected. However the second, and subsequent times it executes, the first few cycles are incorrect.

Ive removed the boilerplate comments etc for brevity.

 int timer = 0;
 
 while (1)
 {
 if (timer >= 9000000) {
 timer = 0;
 HAL_TIM_PWM_Start_DMA(&htim1, TIM_CHANNEL_1, (uint32_t *)pwmData, sizeof(pwmData));
 while (!datasentflag){};
 datasentflag = 0;
 }
 timer++;
 }

The first output of the signal is correct as shown in the scope screenshot here...

The second output of the signal is not correct.

 

There is no change to the pwmData array during the execution, so i would not expect the output to change.

Any ideas on why this could be happening?

[waclawek.jan]

Which STM32?

> Any ideas on why this could be happening?

Yes. Because you are using Cube/HAL functions without understanding what are they doing. Solving your problem means reverse-engineering Cube/HAL, as you need to understand what happens at the register level.

Get life. Ditch Cube, write your own code.

JW

[samsamm777]

STM32F303RET6. Im pretty new to STM32, so i figure using Cube/HAL is a good starting pointing, im sure once im familar with the basics ill be able to move to over hand rolling.

[Tesla DeLorean]

Guessing F3 based on prior posts.

As I recall very fussy about DMA widths, aren't all TIM on F3 16-bit?

Is datasentflag volatile?

Please show enough code to determine context about the buffers, TIM, DMA configuration, IRQHandlers, etc

Diagnostics doesn't have to be played as a guessing game.

[samsamm777]

Yes STM32F303RET6. Include some more information in the post below.

[samsamm777]

/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * @file : main.c
 * @brief : Main program body
 ******************************************************************************
 * @attention
 *
 * Copyright (c) 2022 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 */
/* USER CODE END PD */
 
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
 
/* USER CODE END PM */
 
/* Private variables ---------------------------------------------------------*/
TIM_HandleTypeDef htim1;
DMA_HandleTypeDef hdma_tim1_ch1;
 
/* USER CODE BEGIN PV */
uint16_t pwmData[(24 * LED_NUM) + 300];
int datasentflag = 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_TIM1_Init(void);
/* USER CODE BEGIN PFP */
 
/* USER CODE END PFP */
 
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
{
 HAL_TIM_PWM_Stop_DMA(&htim1, TIM_CHANNEL_1);
 datasentflag = 1;
}
 
void led_init() {
 uint32_t indx = 0;
 
 // G R B
 uint32_t color = (0 << 16 | 255 << 8 | 0 << 0);
 
 for (int i = 0; i < LED_NUM; i++)
 {
 
 for (int j = 23; j >= 0; j--)
 {
	if (color & (1 << j))
	 {
	 pwmData[indx] = 50; // 79% of 66
	 }
	else
	 {
	 pwmData[indx] = 17; // 21% of 66
	 }
 
	indx++;
 }
 
 }
 
 for (int i = 0; i < 300; i++)
 {
 pwmData[indx] = 0;
 indx++;
 }
}
/* 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 */
 led_init();
 
 int timer = 0;
 /* USER CODE END 2 */
 
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
 /* USER CODE END WHILE */
 
 /* USER CODE BEGIN 3 */
 if (timer >= 9000000) {
	timer = 0;
	HAL_TIM_PWM_Start_DMA(&htim1, TIM_CHANNEL_1, (uint32_t *)pwmData, sizeof(pwmData));
	while (!datasentflag){};
	datasentflag = 0;
 }
 timer++;
 
 
 }
 /* USER CODE END 3 */
}
 
/**
 * @brief System Clock Configuration
 * @retval None
 */
void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
 
 /** Initializes the RCC Oscillators according to the specified parameters
 * in the RCC_OscInitTypeDef structure.
 */
 RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
 RCC_OscInitStruct.HSIState = RCC_HSI_ON;
 RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
 RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
 RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6;
 RCC_OscInitStruct.PLL.PREDIV = RCC_PREDIV_DIV1;
 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_1) != HAL_OK)
 {
 Error_Handler();
 }
 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_TIM1;
 PeriphClkInit.Tim1ClockSelection = RCC_TIM1CLK_HCLK;
 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != 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 = 66-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_RESET;
 sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;
 sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
 if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sConfigOC.OCMode = TIM_OCMODE_PWM1;
 sConfigOC.Pulse = 0;
 sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
 sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
 sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
 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.BreakFilter = 0;
 sBreakDeadTimeConfig.Break2State = TIM_BREAK2_DISABLE;
 sBreakDeadTimeConfig.Break2Polarity = TIM_BREAK2POLARITY_HIGH;
 sBreakDeadTimeConfig.Break2Filter = 0;
 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_DMA1_CLK_ENABLE();
 
 /* DMA interrupt init */
 /* DMA1_Channel2_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 0, 0);
 HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
 
}
 
/**
 * @brief GPIO Initialization Function
 * @param None
 * @retval None
 */
static void MX_GPIO_Init(void)
{
 
 /* GPIO Ports Clock Enable */
 __HAL_RCC_GPIOC_CLK_ENABLE();
 __HAL_RCC_GPIOA_CLK_ENABLE();
 
}
 
/* 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 */

Here is my entire main.c file.

 

Timer clock is running at 48MHz

[Piranha]

As Tesla already said, datasentflag variable must be volatile.

[waclawek.jan]

> Im pretty new to STM32, so i figure using Cube/HAL is a good starting pointing,

It's a good starting point if you intend to stick to Cube/HAL and never do anything which you can't simply click in CubeMX. Think Arduino.

> im sure once im familar with the basics ill be able to move to over hand rolling.

No, you won't. You'd need to learn everything from scratch, and simultaneously fight against the "knowledge" you already acquired from Cubeing.

The task you are talking about takes (except setting up RCC and GPIO) writing to perhaps 4-5 registers in TIM and similar number of registers in DMA. By doing that, you know exactly what you are doing and what are the ramifications of your actions, and if in any doubt you can simply look up the details in RM.

**Modified by moderation - It is acceptable to criticize ST products, but please, keep a respectful tone when referring to other community members' work/question **

Your leg, your shot.

JW

[MasterT]

First things to try:

1. htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; // ENABLE

[samsamm777]

Thanks. ill have a look at that field and see if it helps.

[MasterT]

I think, that start /stopping DMA is a bad idea in general. Likely jam / congestion of the data flow happens due to very complex processes involved, init FIFO, triggers, data busses schedulers etc. The better option would be to start DMA with timer only ones, than inside dma_transfer _complete stop a Master clock - another timer, that generates clock for your PWM engine. All it takes is to link two timers. Since master would not be directly interact with DMA, it can be initialised, reset, re-started whenever you like.

[waclawek.jan]

Register-based implementation here. Needs the augmented header from here.

It's for 'L4 as I don't have a 'F3 at hand at the moment - probably the largest difference is, that the 'L4 has a CSELR register selecting the trigger to given DMA channel and 'F3 - quite surprisingly, honestly, given it's contemporary to 'F0 which does have it - does not, it has the older and simpler plain fixed OR. So just remove that line and change the DMA channel to the one which is connected to TIM1_UP (it appears to be Channel 5 from reading RM0316).

JW

[waclawek.jan]

@samsamm777​ , any progress/findings on this?

JW