title: STM32L4 SPI Transfer complete interrupt using DMA fires only once
body: <p>I'm trying to send an array of 10 bytes between 2 nucleo boards (NUCLEO-L432KCU) using SPI and DMA. My goal is to develop the code for the slave board using the Low Level APIs. The master board is used simply for testing and, when everything will work, it will be replaced with the real system.</p>
  
  <p>Before continuing, here are some more details about the system: The sender is configured as master. The code for the master is developed using the HAL API. The Chip Select on the master board is implemented using a GPIO.
  The receiver is configured as slave with the option <strong>Receive only slave</strong> enabled and <strong>Hardware NSS input</strong>. The initialization code is generated automa<strong>G</strong>ically using the CubeMX tool.</p>
  
  <p>With my current implementation I'm able to receive data on the slave board but only once: in practice is seems that the interrupt fires only once and I'm having hard time to figure out what I am missing!</p>
  
  <p>I believe the error has something to do with clearing some interrupt flags. I went through the reference manual but I cannot see what I'm doing wrong.</p>
  
  <p>Following is my code for both sender and receiver.</p>
  
  <hr>
  
  <p><strong>Code for the sender</strong></p>
  
  <p><strong>Note</strong>: Concerning the sender I report only the main function since all the other code is auto-generated. Furthermore, I have checked with a logic analyzer that the code works. Please let me know if you need more details.</p>
  
  <pre><code>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_SPI1_Init();
    MX_SPI3_Init();
    MX_USART2_UART_Init();
    MX_TIM1_Init();
    /* USER CODE BEGIN 2 */
  
    uint8_t test[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A};
    HAL_GPIO_WritePin(SPI1_CS_GPIO_Port,SPI1_CS_Pin,RESET);
    HAL_SPI_Transmit(&amp;hspi1,test,sizeof(test),1000);
    HAL_GPIO_WritePin(SPI1_CS_GPIO_Port,SPI1_CS_Pin,SET);
  
    /* USER CODE END 2 */
  
    /* Infinite loop */
    /* USER CODE BEGIN WHILE */
    while (1)
    {
  
    /* USER CODE END WHILE */
  
    /* USER CODE BEGIN 3 */
  
    }
    /* USER CODE END 3 */
  
  }
  </code></pre>
  
  <hr>
  
  <p><strong>Code for the receiver</strong>
  <strong>Note:</strong> The configuration of the DMA and the SPI is mostly done automatically by the CubeMX tool. The other initializations for my project are provided into the main function.</p>
  
  <pre><code>uint8_t aRxBuffer[10];
  uint8_t received_buffer[100];
  uint16_t cnt = 0;
  
  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_SPI1_Init();
    MX_SPI3_Init();
    MX_USART2_UART_Init();
    MX_TIM1_Init();
    /* USER CODE BEGIN 2 */
  
    // Custom configuration of DMA (after calling function MX_SPI3_INIT()
    // Configure address of the buffer for receiving data
    LL_DMA_ConfigAddresses(DMA2, LL_DMA_CHANNEL_1, LL_SPI_DMA_GetRegAddr(SPI3), (uint32_t)aRxBuffer,LL_DMA_GetDataTransferDirection(DMA2, LL_DMA_CHANNEL_1));
    // Configure data length
    LL_DMA_SetDataLength(DMA2, LL_DMA_CHANNEL_1,10);
    // Enable DMA Transfer complete interrupt
    LL_DMA_EnableIT_TC(DMA2, LL_DMA_CHANNEL_1);
    // LL_DMA_EnableIT_TE(DMA2, LL_DMA_CHANNEL_1);
  
    // We Want the SPI3 to receive 8-bit data
    // Therefore we trigger the RXNE interrupt when the FIFO level is greater than or equal to 1/4 (8bit)
    // See pag. 1221 of the TRM
    LL_SPI_SetRxFIFOThreshold(SPI3,LL_SPI_RX_FIFO_TH_QUARTER);
    LL_SPI_EnableDMAReq_RX(SPI3);
  
    // Enable SPI_3
    LL_SPI_Enable(SPI3);
    // Enable DMA_2,CHANNEL_1
    LL_DMA_EnableChannel(DMA2, LL_DMA_CHANNEL_1);
  
    /* USER CODE END 2 */
  
    /* Infinite loop */
    /* USER CODE BEGIN WHILE */
    while (1)
    {
  
    /* USER CODE END WHILE */
  
    /* USER CODE BEGIN 3 */
  
    }
    /* USER CODE END 3 */
  
  }
  </code></pre>
  
  <p>Following is the IRQ handler (the commented code represents the various attempts to make it working!):</p>
  
  <pre><code>void DMA2_Channel1_IRQHandler(void)
  {
    /* USER CODE BEGIN DMA2_Channel1_IRQn 0 */
  
      // Transfer-complete interrupt management
      if(LL_DMA_IsActiveFlag_TC1(DMA2))
      {
          //LL_DMA_ClearFlag_TC1(DMA2);
          LL_DMA_ClearFlag_GI1(DMA2);
          /* Call function Transmission complete Callback */
          DMA1_TransmitComplete_Callback();
      }
      else if(LL_DMA_IsActiveFlag_TE1(DMA2))
      {
          /* Call Error function */
          int _error = 0;
      }
  
  
        // Enable SPI_3
        //LL_SPI_Disable(SPI3);
        // Enable DMA_2,CHANNEL_1
        //LL_DMA_DisableChannel(DMA2, LL_DMA_CHANNEL_1);
  
        //LL_DMA_EnableIT_TC(DMA2, LL_DMA_CHANNEL_1);
        // LL_DMA_EnableIT_TE(DMA2, LL_DMA_CHANNEL_1);
  
        // We Want the SPI3 to receive 8-bit data
        // Therefore we trigger the RXNE interrupt when the FIFO level is greater than or equal to 1/4 (8bit)
        // See pag. 1221 of the TRM
        //LL_SPI_SetRxFIFOThreshold(SPI3,LL_SPI_RX_FIFO_TH_QUARTER);
        //LL_SPI_EnableDMAReq_RX(SPI3);
  
        // Enable SPI_3
        //LL_SPI_Enable(SPI3);
        // Enable DMA_2,CHANNEL_1
        LL_DMA_EnableChannel(DMA2, LL_DMA_CHANNEL_1);
  
  
  
      //  LL_DMA_EnableIT_TE(DMA2, LL_DMA_CHANNEL_1);
  
    /* USER CODE END DMA2_Channel1_IRQn 0 */
  
    /* USER CODE BEGIN DMA2_Channel1_IRQn 1 */
  
    /* USER CODE END DMA2_Channel1_IRQn 1 */
  }
  </code></pre>
  
  <p>Following is the initialization for the SPI and the DMA (auto-generated):</p>
  
  <pre><code>/* SPI1 init function */
  void MX_SPI1_Init(void)
  {
    LL_SPI_InitTypeDef SPI_InitStruct;
  
    LL_GPIO_InitTypeDef GPIO_InitStruct;
    /* Peripheral clock enable */
    LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_SPI1);
  
    /**SPI1 GPIO Configuration  
    PA1   ------&gt; SPI1_SCK
    PA7   ------&gt; SPI1_MOSI 
    */
    GPIO_InitStruct.Pin = SCLK1_to_SpW_Pin|MOSI1_to_SpW_Pin;
    GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
    GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
    GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    GPIO_InitStruct.Alternate = LL_GPIO_AF_5;
    LL_GPIO_Init(GPIOA, &amp;GPIO_InitStruct);
  
    SPI_InitStruct.TransferDirection = LL_SPI_FULL_DUPLEX;
    SPI_InitStruct.Mode = LL_SPI_MODE_MASTER;
    SPI_InitStruct.DataWidth = LL_SPI_DATAWIDTH_4BIT;
    SPI_InitStruct.ClockPolarity = LL_SPI_POLARITY_LOW;
    SPI_InitStruct.ClockPhase = LL_SPI_PHASE_1EDGE;
    SPI_InitStruct.NSS = LL_SPI_NSS_SOFT;
    SPI_InitStruct.BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV8;
    SPI_InitStruct.BitOrder = LL_SPI_LSB_FIRST;
    SPI_InitStruct.CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE;
    SPI_InitStruct.CRCPoly = 7;
    LL_SPI_Init(SPI1, &amp;SPI_InitStruct);
  
    LL_SPI_SetStandard(SPI1, LL_SPI_PROTOCOL_MOTOROLA);
  
    LL_SPI_EnableNSSPulseMgt(SPI1);
  
  }
  /* SPI3 init function */
  void MX_SPI3_Init(void)
  {
    LL_SPI_InitTypeDef SPI_InitStruct;
  
    LL_GPIO_InitTypeDef GPIO_InitStruct;
    /* Peripheral clock enable */
    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_SPI3);
  
    /**SPI3 GPIO Configuration  
    PA4   ------&gt; SPI3_NSS
    PB3 (JTDO-TRACESWO)   ------&gt; SPI3_SCK
    PB5   ------&gt; SPI3_MOSI 
    */
    GPIO_InitStruct.Pin = LL_GPIO_PIN_4;
    GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
    GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
    GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    GPIO_InitStruct.Alternate = LL_GPIO_AF_6;
    LL_GPIO_Init(GPIOA, &amp;GPIO_InitStruct);
  
    GPIO_InitStruct.Pin = SCLK_from_SpW_Pin|MOSI_from_SpW_Pin;
    GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
    GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
    GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    GPIO_InitStruct.Alternate = LL_GPIO_AF_6;
    LL_GPIO_Init(GPIOB, &amp;GPIO_InitStruct);
  
    /* SPI3 DMA Init */
  
    /* SPI3_RX Init */
    LL_DMA_SetPeriphRequest(DMA2, LL_DMA_CHANNEL_1, LL_DMA_REQUEST_3);
  
    LL_DMA_SetDataTransferDirection(DMA2, LL_DMA_CHANNEL_1, LL_DMA_DIRECTION_PERIPH_TO_MEMORY);
  
    LL_DMA_SetChannelPriorityLevel(DMA2, LL_DMA_CHANNEL_1, LL_DMA_PRIORITY_LOW);
  
    LL_DMA_SetMode(DMA2, LL_DMA_CHANNEL_1, LL_DMA_MODE_NORMAL);
  
    LL_DMA_SetPeriphIncMode(DMA2, LL_DMA_CHANNEL_1, LL_DMA_PERIPH_NOINCREMENT);
  
    LL_DMA_SetMemoryIncMode(DMA2, LL_DMA_CHANNEL_1, LL_DMA_MEMORY_INCREMENT);
  
    LL_DMA_SetPeriphSize(DMA2, LL_DMA_CHANNEL_1, LL_DMA_PDATAALIGN_BYTE);
  
    LL_DMA_SetMemorySize(DMA2, LL_DMA_CHANNEL_1, LL_DMA_MDATAALIGN_BYTE);
  
    /* SPI3 interrupt Init */
    NVIC_SetPriority(SPI3_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(),0, 0));
    NVIC_EnableIRQ(SPI3_IRQn);
  
    SPI_InitStruct.TransferDirection = LL_SPI_SIMPLEX_RX;
    SPI_InitStruct.Mode = LL_SPI_MODE_SLAVE;
    SPI_InitStruct.DataWidth = LL_SPI_DATAWIDTH_4BIT;
    SPI_InitStruct.ClockPolarity = LL_SPI_POLARITY_LOW;
    SPI_InitStruct.ClockPhase = LL_SPI_PHASE_1EDGE;
    SPI_InitStruct.NSS = LL_SPI_NSS_HARD_INPUT;
    SPI_InitStruct.BitOrder = LL_SPI_LSB_FIRST;
    SPI_InitStruct.CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE;
    SPI_InitStruct.CRCPoly = 7;
    LL_SPI_Init(SPI3, &amp;SPI_InitStruct);
  
    LL_SPI_SetStandard(SPI3, LL_SPI_PROTOCOL_MOTOROLA);
  
    LL_SPI_DisableNSSPulseMgt(SPI3);
  
  }
  </code></pre>
  
  <p>Thank you.</p>