ST32F4xx SPI1 DMA funktioniert nicht

[Walter T. (nicolas)]

Hallo zusammen,

ich brauche mal ein paar hilfreiche Augen, denn meine scheinen gerade 
nicht zu reichen. Ich will den SPI1 auf einem STM32F446RE aktivieren. 
Ohne DMA funktioniert das auch so weit. Mit DMA ist allerdings kein 
einziger Takt auf dem Oszilloskop zu sehen und beim zweiten Aufruf der 
DMA-Sende-Funktion wird unendlich lange gewartet, bis das 
"NDTR"-Register keine zu sendenden Bytes mehr anzeigt.

#include "spi.h"
#include "hw_config.h"
#include "myassert.h"
#include "nstdlib.h"
#include "wallclock.h"


/** Auswahl SPI, Ports und Pins */
enum spi_hard_e
{
    spi_hard_STM32F4XX_SPI1_PA5_PA6_PA7,
    spi_hard_STM32F4XX_SPI2_PB13_PB14_PB15,
    spi_hard_STM32F4XX_SPI3_PC10_PC11_PC12,
};


/* In hw_config.h : */
#define SPI_HARD spi_hard_STM32F4XX_SPI1_PA5_PA6_PA7
//#define SPI_HARD spi_hard_STM32F4XX_SPI3_PC10_PC11_PC12


#if defined( STM32F4XX )

    #include "stm32f4xx_rcc.h"
    #include "stm32f4xx_spi.h"


    /** Globale Variablen *************************************************************************/
    /* - */



    /** Hardware-SPI fuer schnelle Anwendungen (z.B. GLCD)
      - duplex mode (RM0390 S. 850f.)
      - Steigende Flanke, Zweite Flanke -> CPHA=0, CPOL=0
        */
    void spi_hard_init(void)
    {
        SPI_InitTypeDef  SPI_InitStructure;
        SPI_TypeDef* SPIx;
        GPIO_InitTypeDef GPIO_InitStructure;
        GPIO_TypeDef *SCK_GPIOx, *MISO_GPIOx, *MOSI_GPIOx;
        uint32_t      SCK_Pin_x,  MISO_Pin_x,  MOSI_Pin_x;
        uint8_t SPIx_IRQn;


        switch( SPI_HARD )
        {
            case spi_hard_STM32F4XX_SPI1_PA5_PA6_PA7:
                /* Enable the SPI clock */
                RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);

                SCK_GPIOx  = GPIOA;
                SCK_Pin_x  = GPIO_Pin_5;
                MISO_GPIOx = GPIOA;
                MISO_Pin_x = GPIO_Pin_6;
                MOSI_GPIOx = GPIOA;
                MOSI_Pin_x = GPIO_Pin_7;

                SPIx = SPI1;
                SPIx_IRQn = SPI1_IRQn;

                /* Connect SPI pins to AF5 */
                GPIO_PinAFConfig(SCK_GPIOx,  GPIO_PinSource5, GPIO_AF_SPI1);
                GPIO_PinAFConfig(MISO_GPIOx, GPIO_PinSource6, GPIO_AF_SPI1);
                GPIO_PinAFConfig(MOSI_GPIOx, GPIO_PinSource7, GPIO_AF_SPI1);

                break;

            case spi_hard_STM32F4XX_SPI2_PB13_PB14_PB15:
                /* ungetestet */

                /* Enable the SPI clock */
                RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);

                SCK_GPIOx  = GPIOB;
                SCK_Pin_x  = GPIO_Pin_13;
                MISO_GPIOx = GPIOB;
                MISO_Pin_x = GPIO_Pin_14;
                MOSI_GPIOx = GPIOB;
                MOSI_Pin_x = GPIO_Pin_15;

                SPIx = SPI2;
                SPIx_IRQn = SPI2_IRQn;

                /* Connect SPI pins to AF5 */
                GPIO_PinAFConfig(SCK_GPIOx,  GPIO_PinSource13, GPIO_AF_SPI2);
                GPIO_PinAFConfig(MISO_GPIOx, GPIO_PinSource14, GPIO_AF_SPI2);
                GPIO_PinAFConfig(MOSI_GPIOx, GPIO_PinSource15, GPIO_AF_SPI2);

                break;

            case spi_hard_STM32F4XX_SPI3_PC10_PC11_PC12:

                /* Enable the SPI clock */
                RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE);

                SCK_GPIOx  = GPIOC;
                SCK_Pin_x  = GPIO_Pin_10;
                MISO_GPIOx = GPIOC;
                MISO_Pin_x = GPIO_Pin_11;
                MOSI_GPIOx = GPIOC;
                MOSI_Pin_x = GPIO_Pin_12;

                SPIx = SPI3;
                SPIx_IRQn = SPI3_IRQn;

                /* Connect SPI pins to AF 6 */
                GPIO_PinAFConfig(SCK_GPIOx,  GPIO_PinSource10, GPIO_AF_SPI3);
                GPIO_PinAFConfig(MISO_GPIOx, GPIO_PinSource11, GPIO_AF_SPI3);
                GPIO_PinAFConfig(MOSI_GPIOx, GPIO_PinSource12, GPIO_AF_SPI3);

                break;
            default:
                error("Not implemented for other SPI");
        }


        GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
        GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_DOWN;

        /* SPI SCK pin configuration */
        GPIO_InitStructure.GPIO_Pin = SCK_Pin_x;
        GPIO_Init(SCK_GPIOx, &GPIO_InitStructure);

        /* SPI  MISO pin configuration */
        GPIO_InitStructure.GPIO_Pin =  MISO_Pin_x;
        GPIO_Init(MISO_GPIOx, &GPIO_InitStructure);

        /* SPI  MISO pin configuration */
        GPIO_InitStructure.GPIO_Pin =  MOSI_Pin_x;
        GPIO_Init(MOSI_GPIOx, &GPIO_InitStructure);

        SPI_I2S_DeInit(SPIx);

        /* SPI configuration */
        /* SPIx->CR1 RXONLY */
        /* SPIx->CR1.SSI=0 (active low) */
        SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
        SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
        SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
        SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
        SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
        SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2; /* spaeter noch anpassen */
        SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
        SPI_InitStructure.SPI_CRCPolynomial = 7; /* unnoetig */
        SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
        SPI_Init(SPIx, &SPI_InitStructure);


        /* DMA Configuration - vorerst nur nur fuer SPI1 */
        /* DMA1 Clock */
        assert( SPIx == SPI1 );
        RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);

        DMA_InitTypeDef DMA_InitStruct;
        DMA_StructInit(&DMA_InitStruct);
        DMA_InitStruct.DMA_Channel = DMA_Channel_3;
        DMA_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)&(SPI1->DR);
        DMA_InitStruct.DMA_Memory0BaseAddr = 0;
        DMA_InitStruct.DMA_BufferSize = 0;
        DMA_InitStruct.DMA_DIR = DMA_DIR_MemoryToPeripheral;
        DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
        DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
        DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
        DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
        DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;
        DMA_InitStruct.DMA_Priority = DMA_Priority_Medium;
        DMA_InitStruct.DMA_FIFOMode = DMA_FIFOMode_Disable;
        DMA_InitStruct.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull;
        DMA_InitStruct.DMA_MemoryBurst = DMA_MemoryBurst_Single;
        DMA_InitStruct.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
        DMA_Init(DMA2_Stream3, &DMA_InitStruct);

        /* DMA-Interrupt wird erst behandelt, wenn Chip Select implementiert wird*/
        //DMA_ITConfig(DMA1_Stream6, DMA_IT_TC, ENABLE);
        DMA_Cmd(DMA2_Stream3, ENABLE);


        /* Configure the SPI interrupt priority */
        /* Interrupts 0, 1, 2 sind anderweitig belegt und werden auch aufgerufen */
        /*NVIC_SetPriority(SPIx_IRQn, 4); */
        /*NVIC_EnableIRQ(SPIx_IRQn); */


        /* Enable the Rx buffer not empty interrupt */
        /* SPI2->CR2 RXNEIE Bit wird gesetzt */
        SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_RXNE, DISABLE);


        /* Enable the SPI peripheral */
        SPI_Cmd(SPIx, ENABLE);
    }





    /** Abschalten
     *
     * @note Keine komplette Deinitialisierung noetig, sleep modi werden nicht benutzt */
    void spi_hard_deinit(void)
    {
        SPI_TypeDef* SPIx;
        switch( SPI_HARD )
        {
            case spi_hard_STM32F4XX_SPI1_PA5_PA6_PA7:
                SPIx = SPI1;

            case spi_hard_STM32F4XX_SPI2_PB13_PB14_PB15:
                SPIx = SPI2;
                break;

            case spi_hard_STM32F4XX_SPI3_PC10_PC11_PC12:
                SPIx = SPI3;
                break;
        }
        SPI_Cmd(SPIx, DISABLE);
    }




    /** Einzelnes Byte ueber SPI senden, nichts empfangen, MSB first */
    uint8_t spi_hard_sendbyte(uint8_t byte)
    {
        uint8_t in = 0;

        SPI_TypeDef* SPIx;
        switch( SPI_HARD )
        {
            case spi_hard_STM32F4XX_SPI1_PA5_PA6_PA7:
                SPIx = SPI1;
                break;

            case spi_hard_STM32F4XX_SPI2_PB13_PB14_PB15:
                SPIx = SPI2;
                break;

            case spi_hard_STM32F4XX_SPI3_PC10_PC11_PC12:
                SPIx = SPI3;
                break;
        }

        /*!< Loop while DR register in not empty */
        while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET);

        /*!< Send byte through the SPI1 peripheral */
        SPI_I2S_SendData(SPIx, byte);

        /*!< Wait to receive a byte */
        while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE) == RESET);

        /*!< Return the byte read from the SPI bus */
        in = SPI_I2S_ReceiveData(SPIx);

        return in;
    }



    /** Daten per DMA senden - bleibt immer stecken*/
    void spi_hard_senddma(uint8_t *data, size_t len)
    {
        static uint32_t cnt = 0;
        cnt++;

        DMA_Stream_TypeDef* DMAy_Streamx = DMA2_Stream3;

        /* Warten bis vorheriger Transfer abgeschlossen */
        while( DMAy_Streamx->NDTR != 0 );

        DMA_Cmd(DMAy_Streamx, DISABLE);
        //DMA_ITConfig(DMAy_Streamx, DMA_IT_TC, DISABLE);

        /* Neuen Block fuers Senden vorbereiten */
        DMAy_Streamx->M0AR = (uint32_t) data;
        DMA_SetCurrDataCounter(DMAy_Streamx, len);

        if( len )
        {
            //DMA_ITConfig(DMAy_Streamx, DMA_IT_TC, ENABLE);
            DMA_Cmd(DMAy_Streamx, ENABLE);
        }
    }

Egal wie groß oder wie klein das Array ist, was spi_hard_senddma() 
übergeben wird - beim zweiten  Aufruf ist in NDTR immer noch die volle 
Länge drin. Was ja auch zum Bild auf dem Oszilloskop passt, weil nichts 
gesendet wird. Es sieht aus, als fehle irgendeine Form der 
Sende-Freigabe.

Was sehen eure Augen mehr als meine?

[GL (Gast)]

Hab mir das ganze jetzt nicht durchgelesen, aber prinzipiell sollte ein 
SPI DMA Transfer mit 3-4 Zeilen erschlagen sein. Guck mal in die 
Beispiele, die die Cube mitliefert.

[Walter T. (nicolas)]

Die Streams für TX und RX waren vertauscht.