DMA Transfer Complete interrupt nach einem Zeichen statt fünf

[Markus G. (the_grue)]

Servus!

Nach meiner Lektüre vom STM32F303 Reference Manual (RM0316) verstehe ich 
den DMA transfer so, daß ein Tranfer-Complete-Interrupt ausgelöst wird, 
wenn der komplette Transfer (also wenn DMA_CNDTRx==0 geworden ist).

Ich verstehe einfach nicht warum, aber bei mir wird die entsprechende 
ISR immer schon aufgerufen, nachdem 1 Zeichen übertragen wurde. Die 
Anwendung ist: Einen Puffer am UART via DMA ausgeben. Damit nicht gleich 
der nächste Transfer gestartet wird, solange der aktuelle nicht fertig 
ist, blockiere ich den Transfer mit einem flag (als pseudo-mutex). Vor'm 
Transfer wird auf flag==0 gewartet, dann flag=1 gesetzt und die ISR soll 
am Transferende flag=0 setzen. Wenn jetzt schon nach dem ersten Zeichen 
das Flag gelöscht wird, rent der Code natürlich in ein HAL_BUSY (oder 
so).

Im beigefügten Oszyllogramm sieht man die (decodierte) TX-Leitung (grün) 
und einen kurzen Peak (rot), wenn die ISR zum falschen Zeitpunkt 
aufgerufen wird.

Ich hab' schon alles mögliche probiert, komme aber nicht dahinter. Könnt 
Ihr mir bitte weiterhelfen? Das ist der Code:

int dmaTxMutex = 0;  // Int used as mutex to prevent overlapping DMA transfers

static UART_HandleTypeDef UART_HandleStructure;
static DMA_HandleTypeDef  DMA_Handle;

#define EMBER_COM_USART_TX_DMA_CHANNEL    DMA1_Channel2
#define EMBER_COM_USART_TX_DMA_IRQ        DMA1_Channel2_IRQn
#define EMBER_COM_USART_TX_DMA_IRQHANDLER DMA1_Channel2_IRQHandler

void init()
{
    //Configure USART TX GPIO as alternate function push-pull
    GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStructure.Pin = EMBER_COM_TX_PIN;
    GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
    GPIO_InitStructure.Alternate = GPIO_AF7_USART3;
    HAL_GPIO_Init(EMBER_COM_TX_PORT, &GPIO_InitStructure);

    // RX, RTS, CTS omitted

    //Configure USART
    UART_HandleStructure.Instance = USART3;
    UART_HandleStructure.Init.BaudRate = 115200;
    UART_HandleStructure.Init.WordLength = UART_WORDLENGTH_8B;
    UART_HandleStructure.Init.Parity = EMBER_COM_PARITY;
    UART_HandleStructure.Init.StopBits = UART_STOPBITS_1;
    UART_HandleStructure.Init.HwFlowCtl = UART_HWCONTROL_RTS_CTS;
    UART_HandleStructure.Init.Mode = UART_MODE_TX_RX;

    if(HAL_UART_Init(&UART_HandleStructure) != HAL_OK)
    {
        ESMxError_SetId( EID_UART );
    }

    __HAL_UART_ENABLE(&UART_HandleStructure);

    //Enable USART (top level) NVIC interrupt and configure the priority
    HAL_NVIC_SetPriority(EMBER_COM_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(EMBER_COM_IRQn);

    // Configure DMA to send data via UART
    DMA_Handle.Instance                 = EMBER_COM_USART_TX_DMA_CHANNEL;
    DMA_Handle.Init.Direction           = DMA_MEMORY_TO_PERIPH;
    DMA_Handle.Init.PeriphInc           = DMA_PINC_DISABLE;
    DMA_Handle.Init.MemInc              = DMA_MINC_ENABLE;
    DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    DMA_Handle.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;
    DMA_Handle.Init.Mode                = DMA_NORMAL;
    DMA_Handle.Init.Priority            = DMA_PRIORITY_HIGH;

    if (HAL_DMA_Init(&DMA_Handle) != HAL_OK)
    {
        /* Initialization Error */
        ESMxError_SetId( EID_DMA );
    }

    __HAL_LINKDMA(&UART_HandleStructure, hdmatx, DMA_Handle);

    /*##-6- Configure NVIC for DMA transfer complete/error interrupts ##########*/
    /* Set Interrupt Group Priority */
    HAL_NVIC_SetPriority(EMBER_COM_USART_TX_DMA_IRQ, 0, 0);

    /* Enable the DMA STREAM global Interrupt */
    HAL_NVIC_EnableIRQ(EMBER_COM_USART_TX_DMA_IRQ);

}


void EMBER_COM_USART_TX_DMA_IRQHANDLER( void )
{
  DebugPinOn( DBG_RED );

  // Disable interrupt to avoid infinite loop. Interrups are enabled
  // again automaticaly when running HAL_UART_Transmit_DMA
  __HAL_DMA_DISABLE_IT( &DMA_Handle, DMA_IT_TC | DMA_IT_HT | DMA_IT_TE );

  dmaTxMutex = 0;


  DebugPinOff( DBG_RED );
}

//------------------------------------------------------------------------------
/// \brief Used to write to the NCP
///
/// \param handle: ignored
/// \param buffer: data to write
/// \param size: size of buffer
///
/// \return number of bytes written
//------------------------------------------------------------------------------
size_t emberWrite(int handle, const unsigned char * buffer, size_t size)
{
  HAL_StatusTypeDef status = HAL_OK;

  while (dmaTxMutex>0 )
  {
    //OS_Delayus( 32 ); // wake approx. three times per transfered byte
    DebugPinToggle( DBG_YELLOW );
  }
  dmaTxMutex = 1; // take the mutex. dma irq releases it

  status = HAL_UART_Transmit_DMA(&UART_HandleStructure, (uint8_t*) buffer, size);

  if ( status != HAL_OK)
  {
    ESMxError_SetId( EID_DMA );
  }

  return size;
}