unexpected GPIO behavior

[LBaum.3]

Hi ST community,

I am interrested in using the STM32F767-Nucleo board for SPI communication. My system is as follows. I have one STM32F767-Nucleo board which is my SPI slave and a Raspberry Pi which acts as SPI master device. The Raspi should read data via SPI from the Nucleo board. There is also one wire which is used from the Nucleo board to tell the Raspi when data is ready to be read. So every time data is ready the STM32 toggles this GPIO pin and the Raspi gets an interrupt and forces a read command.

Now my problem is not the SPI communication, no this works very well. The problem is the GPIO pin which forces interrupts at the Raspi and after that SPI read commands for the STM32. After some time of working properly the GPIO pin does nothing for about 400ms to 500ms and I don't know why this happens (see picture GPIO_stop_working.png) .

I use the DMA to transfer data from the memory to the SPI peripheral. If timer 3 generates an Interrupt (this happens every 100ms) HAL_TIM_PeriodElapsedCallback will be called. In the callback function I toggle GPIO pin PG2 which is the wire that tells the Raspi data are ready to be read. If the first timer interrupt occurs the STM32 will send only one number and after that at every timer interrupt data gets sent with HAL_SPI_Transmit_DMA.

My first idea was maybe the Raspi causes this discrepancy at GPIO PG2 but I replaced it with antother STM32F767-Nucleo board which has the same task as the Raspi and the same problem occurs. Therefore I think the problem is at the side of the Nucleo board and not the Raspi.

ps: The code from the STM32 is in the first reply of this post.

-Lukas

[LBaum.3]

main.c

#include "main.h"
 
#include <string.h>
#include <math.h>
 
#define FULLBUFFERSIZE 		4096
#define HALFBUFFERSIZE 		FULLBUFFERSIZE/2
#define SINETABLESIZE		FULLBUFFERSIZE
 
ADC_HandleTypeDef hadc1;
DMA_HandleTypeDef hdma_adc1;
 
DAC_HandleTypeDef hdac;
DMA_HandleTypeDef hdma_dac1;
 
SPI_HandleTypeDef hspi3;
DMA_HandleTypeDef hdma_spi3_tx;
 
TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim3;
 
UART_HandleTypeDef huart3;
 
PCD_HandleTypeDef hpcd_USB_OTG_FS;
 
/* USER CODE BEGIN PV */
uint16_t bufferByteNumber = FULLBUFFERSIZE;
uint16_t adcData[FULLBUFFERSIZE];
uint16_t dacData[SINETABLESIZE];
 
uint8_t sentDataSize = 0;
uint8_t TimSentFirstHalf = 0;
 
 
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_USART3_UART_Init(void);
static void MX_USB_OTG_FS_PCD_Init(void);
static void MX_ADC1_Init(void);
static void MX_SPI3_Init(void);
static void MX_DAC_Init(void);
static void MX_TIM2_Init(void);
static void MX_TIM3_Init(void);
 
void initDacData(){
	for(int i=0; i<SINETABLESIZE; i++){
		dacData[i] = (uint16_t){1500.0*sin(2.0*M_PI*(float)i/SINETABLESIZE)+2000.5};
	}
}
 
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim){
	if(htim == &htim3){
		HAL_GPIO_TogglePin(GPIOG, GPIO_PIN_2);
		if(sentDataSize){
			if(TimSentFirstHalf){
				HAL_SPI_Transmit_DMA(&hspi3, &dacData[HALFBUFFERSIZE], HALFBUFFERSIZE);
				TimSentFirstHalf = 0;
			}else{
				HAL_SPI_Transmit_DMA(&hspi3, dacData, HALFBUFFERSIZE);
				TimSentFirstHalf = 1;
			}
		}else{
			HAL_SPI_Transmit_DMA(&hspi3, &bufferByteNumber, 1);
			sentDataSize = 1;
		}
	}
}
 
int main(void)
{
 /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
 HAL_Init();
 
 /* Configure the system clock */
 SystemClock_Config();
 
 /* Initialize all configured peripherals */
 MX_GPIO_Init();
 MX_DMA_Init();
 MX_USART3_UART_Init();
 MX_USB_OTG_FS_PCD_Init();
 MX_ADC1_Init();
 MX_SPI3_Init();
 MX_DAC_Init();
 MX_TIM2_Init();
 MX_TIM3_Init();
 
 initDacData();
 
 //DAC ADC with DMA
// HAL_TIM_Base_Start(&htim2);
// HAL_ADC_Start_DMA(&hadc1, (uint32_t*)adcData, FULLBUFFERSIZE);
// HAL_DAC_Start_DMA(&hdac, DAC_CHANNEL_1, (uint32_t *)dacData, SINETABLESIZE, DAC_ALIGN_12B_R);
 
 //start Tim3 with interrupt
 HAL_TIM_Base_Start_IT(&htim3);
 
 while (1){}
}

[LBaum.3]

other functions used in main.c

void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
 /** Configure LSE Drive Capability*/
 HAL_PWR_EnableBkUpAccess();
 /** Configure the main internal regulator output voltage*/
 __HAL_RCC_PWR_CLK_ENABLE();
 __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE3);
 /** 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_BYPASS;
 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
 RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
 RCC_OscInitStruct.PLL.PLLM = 4;
 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();
 }
 /** Activate the Over-Drive mode*/
 if (HAL_PWREx_EnableOverDrive() != 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_DIV8;
 
 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK)
 {
 Error_Handler();
 }
 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART3|RCC_PERIPHCLK_CLK48;
 PeriphClkInitStruct.Usart3ClockSelection = RCC_USART3CLKSOURCE_PCLK1;
 PeriphClkInitStruct.Clk48ClockSelection = RCC_CLK48SOURCE_PLL;
 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_ADC1_Init(void)
{
 ADC_ChannelConfTypeDef sConfig = {0};
 /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)*/
 hadc1.Instance = ADC1;
 hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV8;
 hadc1.Init.Resolution = ADC_RESOLUTION_12B;
 hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
 hadc1.Init.ContinuousConvMode = ENABLE;
 hadc1.Init.DiscontinuousConvMode = DISABLE;
 hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
 hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
 hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
 hadc1.Init.NbrOfConversion = 1;
 hadc1.Init.DMAContinuousRequests = ENABLE;
 hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
 if (HAL_ADC_Init(&hadc1) != HAL_OK)
 {
 Error_Handler();
 }
 /** Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.*/
 sConfig.Channel = ADC_CHANNEL_9;
 sConfig.Rank = ADC_REGULAR_RANK_1;
 sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
 if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }
}
static void MX_DAC_Init(void)
{
 DAC_ChannelConfTypeDef sConfig = {0};
 /** DAC Initialization
 */
 hdac.Instance = DAC;
 if (HAL_DAC_Init(&hdac) != HAL_OK)
 {
 Error_Handler();
 }
 /** DAC channel OUT1 config
 */
 sConfig.DAC_Trigger = DAC_TRIGGER_T2_TRGO;
 sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
 if (HAL_DAC_ConfigChannel(&hdac, &sConfig, DAC_CHANNEL_1) != HAL_OK)
 {
 Error_Handler();
 }
 
}
static void MX_SPI3_Init(void)
{
 /* SPI3 parameter configuration*/
 hspi3.Instance = SPI3;
 hspi3.Init.Mode = SPI_MODE_SLAVE;
 hspi3.Init.Direction = SPI_DIRECTION_2LINES;
 hspi3.Init.DataSize = SPI_DATASIZE_16BIT;
 hspi3.Init.CLKPolarity = SPI_POLARITY_LOW;
 hspi3.Init.CLKPhase = SPI_PHASE_2EDGE;
 hspi3.Init.NSS = SPI_NSS_SOFT;
 hspi3.Init.FirstBit = SPI_FIRSTBIT_MSB;
 hspi3.Init.TIMode = SPI_TIMODE_DISABLE;
 hspi3.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
 hspi3.Init.CRCPolynomial = 7;
 hspi3.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
 hspi3.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
 if (HAL_SPI_Init(&hspi3) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_TIM2_Init(void)
{
 TIM_ClockConfigTypeDef sClockSourceConfig = {0};
 TIM_MasterConfigTypeDef sMasterConfig = {0};
 
 htim2.Instance = TIM2;
 htim2.Init.Prescaler = 0;
 htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
 htim2.Init.Period = 1049;
 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_TIM3_Init(void)
{
 TIM_ClockConfigTypeDef sClockSourceConfig = {0};
 TIM_MasterConfigTypeDef sMasterConfig = {0};
 
 htim3.Instance = TIM3;
 htim3.Init.Prescaler = 959;
 htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
 htim3.Init.Period = 9999;
 htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
 htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
 if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
 {
 Error_Handler();
 }
 sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
 if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
 sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
 if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_USART3_UART_Init(void)
{
 huart3.Instance = USART3;
 huart3.Init.BaudRate = 115200;
 huart3.Init.WordLength = UART_WORDLENGTH_8B;
 huart3.Init.StopBits = UART_STOPBITS_1;
 huart3.Init.Parity = UART_PARITY_NONE;
 huart3.Init.Mode = UART_MODE_TX_RX;
 huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
 huart3.Init.OverSampling = UART_OVERSAMPLING_16;
 huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
 huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
 if (HAL_UART_Init(&huart3) != HAL_OK)
 {
 Error_Handler();
 }
}

[LBaum.3]

other functions used in main.c extended

static void MX_USB_OTG_FS_PCD_Init(void)
{
 hpcd_USB_OTG_FS.Instance = USB_OTG_FS;
 hpcd_USB_OTG_FS.Init.dev_endpoints = 6;
 hpcd_USB_OTG_FS.Init.speed = PCD_SPEED_FULL;
 hpcd_USB_OTG_FS.Init.dma_enable = DISABLE;
 hpcd_USB_OTG_FS.Init.phy_itface = PCD_PHY_EMBEDDED;
 hpcd_USB_OTG_FS.Init.Sof_enable = ENABLE;
 hpcd_USB_OTG_FS.Init.low_power_enable = DISABLE;
 hpcd_USB_OTG_FS.Init.lpm_enable = DISABLE;
 hpcd_USB_OTG_FS.Init.vbus_sensing_enable = ENABLE;
 hpcd_USB_OTG_FS.Init.use_dedicated_ep1 = DISABLE;
 if (HAL_PCD_Init(&hpcd_USB_OTG_FS) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_DMA_Init(void)
{
 /* DMA controller clock enable */
 __HAL_RCC_DMA2_CLK_ENABLE();
 __HAL_RCC_DMA1_CLK_ENABLE();
 /* DMA interrupt init */
 /* DMA1_Stream5_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 0, 0);
 HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
 /* DMA1_Stream7_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(DMA1_Stream7_IRQn, 0, 0);
 HAL_NVIC_EnableIRQ(DMA1_Stream7_IRQn);
 /* DMA2_Stream0_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 0, 0);
 HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
 
}
 
static void MX_GPIO_Init(void)
{
 GPIO_InitTypeDef GPIO_InitStruct = {0};
 
 /* GPIO Ports Clock Enable */
 __HAL_RCC_GPIOC_CLK_ENABLE();
 __HAL_RCC_GPIOH_CLK_ENABLE();
 __HAL_RCC_GPIOA_CLK_ENABLE();
 __HAL_RCC_GPIOB_CLK_ENABLE();
 __HAL_RCC_GPIOD_CLK_ENABLE();
 __HAL_RCC_GPIOG_CLK_ENABLE();
 
 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(GPIOB, LD1_Pin|LD3_Pin|LD2_Pin, GPIO_PIN_RESET);
 
 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(GPIOG, GPIO_PIN_2|USB_PowerSwitchOn_Pin, GPIO_PIN_RESET);
 
 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
 
 /*Configure GPIO pin : USER_Btn_Pin */
 GPIO_InitStruct.Pin = USER_Btn_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 HAL_GPIO_Init(USER_Btn_GPIO_Port, &GPIO_InitStruct);
 
 /*Configure GPIO pins : RMII_MDC_Pin RMII_RXD0_Pin RMII_RXD1_Pin */
 GPIO_InitStruct.Pin = RMII_MDC_Pin|RMII_RXD0_Pin|RMII_RXD1_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
 HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 
 /*Configure GPIO pins : RMII_REF_CLK_Pin RMII_MDIO_Pin */
 GPIO_InitStruct.Pin = RMII_REF_CLK_Pin|RMII_MDIO_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
 /*Configure GPIO pin : PA7 */
 GPIO_InitStruct.Pin = GPIO_PIN_7;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;
 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
 /*Configure GPIO pins : LD1_Pin LD3_Pin LD2_Pin */
 GPIO_InitStruct.Pin = LD1_Pin|LD3_Pin|LD2_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
 /*Configure GPIO pin : RMII_TXD1_Pin */
 GPIO_InitStruct.Pin = RMII_TXD1_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
 HAL_GPIO_Init(RMII_TXD1_GPIO_Port, &GPIO_InitStruct);
 
 /*Configure GPIO pins : PG2 USB_PowerSwitchOn_Pin */
 GPIO_InitStruct.Pin = GPIO_PIN_2|USB_PowerSwitchOn_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
 
 /*Configure GPIO pin : USB_OverCurrent_Pin */
 GPIO_InitStruct.Pin = USB_OverCurrent_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 HAL_GPIO_Init(USB_OverCurrent_GPIO_Port, &GPIO_InitStruct);
 
 /*Configure GPIO pin : PD2 */
 GPIO_InitStruct.Pin = GPIO_PIN_2;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
 
 /*Configure GPIO pins : RMII_TX_EN_Pin RMII_TXD0_Pin */
 GPIO_InitStruct.Pin = RMII_TX_EN_Pin|RMII_TXD0_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
 HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
}
 
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 */
}

[TDK]

Looks like it's stuck in another interrupt handler somewhere. The edge after the delay is delayed. Review your other interrupts to ensure none of them are blocking. If you're stuck, instrument SysTick handler to monitor the currently active interrupt to find out where the delay is happening.

[LBaum.3]

Hi @TDK​ ,

thank you for your fast reply.

Great idea, this could be the problem. I think no other interrupts are blocking but to be sure I would like to use the SysTick handler as you mentioned. My Problem is that I don't know how to do this. So could you please explain to me how I can use the SysTick handler for monitoring the currently active interrupt and how this works?

-Lukas

[TDK]

Another perhaps easier verification would be to toggle a GPIO pin in the main loop to verify interrupts are handled quickly enough.

Your code looks pretty simple, not sure what the issue could be. Perhaps something in USB is blocking. Try removing functionality until it works.

[LBaum.3]

Hi @TDK​ ,

I disabled things I don't need like USB, USART and Timer 2. I also toggled a GPIO pin in the while loop. As you can see in picture "interrupt.png" the pin toggling from the while loop (channel 4) gets interrupted when the edge of channel 3 occurs. But I can still see that the GPIO pin which forces interrupts at the Raspi stops working some time.

-Lukas

[TDK]

Can you provide the same plot as in your original post but with the gpio pin toggling included? I suspect it will not be toggling during the glitch period.
Is your clock source from a crystal and is it stable? You could output MCO on a pin and verify it works continuously.

[TDK]

Sounds like it was stuck in another interrupt somewhere. Glad you got it sorted.

> Some time after sending the MISO line remains high instead of low.

MISO staying high is not a problem. It does not violate any protocol or convention. It probably keeps the value of the last bit sent, or the next bit to send, although neither is a requirement. The only requirement is that the signal is valid on the clock edge where it is sampled.

And if the transfer is done, then the value of MISO is "don't care".

[LBaum.3]

Yes I think so.

Ok, that's fine. Then there is just one problem. Sometimes the whole data package contain the same value.

Do you have any idea what's the reason for this?

[TDK]

Perhaps the call to HAL_SPI_Transmit_DMA fails due to it already being busy. You should monitor the return value to detect errors.