STM32F4 - SPI und DMA

[Op C. (opcode_x64)]

Sehr geehrte Forumuser,

ich beschäftige mich zur Zeit mit SPI und DMA auf dem STM32F4 Discovery 
Board. Ich habe eine allgemeine Frage:

Ist es möglich SPI und DMA nur im Datenempfangmodus zu betreiben ? D.h. 
ich verschicke die Daten ohne DMA, also mit SPI2->DR = .... empfange sie 
aber mit DMA ?! Oder muss ich den Datentransfer zum Slave (Master ist 
der STM32F407) ebenfalls mit DMA ausführen ?

Danke.

[(prx) A. K. (prx)]

Tx und Rx sind bei SPI technisch gekoppelt. Wenn der Master ein Byte 
empfangen will, dann muss er dazu eines senden. Auch wenn da nichts 
Sinnvolles drinstehen sollte.

Wenn der Inhalt von Tx keine Rolle spielt, dann kannst du den dazu 
gehörenden DMA-Kanal aber auf nichtinkrementierende Speicheradresse 
einstellen. Umgekehrt ebenso - das reale Ende einer Tx-Übertragung 
kriegt man bei SPI mit DMA ohnehin nur dadurch raus, indem man auf das 
Ende des Rx-Kanals wartet (jedenfalls bei den F1xx).

Wenn das die falsche Antwort war, dann solltest du etwas mehr drüber 
verraten, um was es geht.

[Op C. (opcode_x64)]

Hallo A.K.,

danke für deine Antwort.

Ich versuche dieses Programm:
Beitrag "AD7680 (SPI) + STM32F4Discovery"

auf DMA umzubauen. Ich möchte nicht nur ein Abtastwert, sondern 10k oder 
20k Werte abtasten per DMA schnell "wegspeichern". Ohne DMA Version kann 
ich einen Abtastwert ohne Probleme auslesen. Ich möchte quasi erstmal 
eine gewisse Anzahl von Bytes, sagen wir mal, 1000 per DMA von dem 
Analog Digital Umsetzer auslesen. Ich muss den DMA so konfigurieren, 
dass dieser jedesmal wenn ich etwas ausgelesen habe, wieder etwas 
gesendet wird, sonst geht das auslesen ja nicht, wie du beschrieben 
hast.

[(prx) A. K. (prx)]

Wie soll das zeitlich ablaufen? Nonstop, oder in kontrolliertem 
Zeitraster?

Grundprinzip: Je einen DMA Kanal für Rx und Tx auf den Speicherblock für 
die zu empfangenen Daten programmieren, N Bytes. Was dabei gesendet wird 
ist ja wohl egal. Der Rx DMA Kanal triggert auf den SPI Empfang. Für 
nonstop Modus triggert der Tx DMA Kanal auf Tx vom SPI. Für 
Zeitraster-Modus triggert der Tx DMA Kanal auf einen Timer.

Jedes mal wenn ein Tx DMA Byte im SPI landet und rausgeschoben wird 
kommt eines retour und wird per Rx DMA im Block gespeichert. Das Tx DMA 
dient hier nur zur Taktung.

Läuft so völlig automatisch ab.

[Op C. (opcode_x64)]

Hallo A.K.,

danke für die schnelle Rückmeldung. Hättest du eventuell ein 
Minimal-Beispiel oder eine Art Pseudo-Code für dein "Grundprinzip" ?

Danke

[(prx) A. K. (prx)]

Testcode für SPI mit DMA, vom STM32F103.

Verwendet Teile eigener Umgebung und einige eigene Defines der 
Peripherie, also versuch gar nicht erst, ihn direkt zu verwenden.

void
spi_init(int size, int mode)
{
    // enable DMA1, SPI2 and PortB clocks
    BBPeriphMask(RCC->AHBENR,  RCC_AHBENR_DMA1EN)  = 1;
    BBPeriphMask(RCC->APB1ENR, RCC_APB1ENR_SPI2EN) = 1;
    BBPeriphMask(RCC->APB2ENR, RCC_APB2ENR_IOPBEN) = 1;

    // GPIOB:
    //  9  = IRQ,  port input with pullup
    //  12 = SS,   port output
    //  13 = SCK,  alternate output
    //  14 = MISO, alternate input
    //  15 = MOSI, alternate output
    gpio_config(GPIOB, 1<<9,        GPIO_Mode_Input       | GPIO_Input_Pullup);
    gpio_config(GPIOB, 1<<12,       GPIO_Mode_Output50MHz | GPIO_Output_PushPull);
    gpio_config(GPIOB, 1<<13|1<<15, GPIO_Mode_Output50MHz | GPIO_AltOut_PushPull);
    gpio_config(GPIOB, 1<<14,       GPIO_Mode_Input       | GPIO_Input_Pullup);

    // DMA:
    //  4 = RX
    //  5 = TX
    DMA1_Channel4->CCR = DMA_CCR_DIR_per2mem
                       | DMA_CCR_MINC
                       | DMA_CCR_PSIZE_16bits
                       | (size==16 ? DMA_CCR_MSIZE_16bits : DMA_CCR_MSIZE_8bits)
                       | DMA_CCR_PL_high
                       | DMA_CCR_TCIE;
    DMA1_Channel5->CCR = DMA_CCR_DIR_mem2per
                       | DMA_CCR_MINC
                       | DMA_CCR_PSIZE_16bits
                       | (size==16 ? DMA_CCR_MSIZE_16bits : DMA_CCR_MSIZE_8bits)
                       | DMA_CCR_PL_low;
    DMA1_Channel4->CPAR = (unsigned)&SPI2->DR;
    DMA1_Channel5->CPAR = (unsigned)&SPI2->DR;

    SPI2->CR1 = (size==16 ? SPI_CR1_DFF_16bit : SPI_CR1_DFF_8bit)
              | SPI_CR1_MSBFIRST
              | SPI_CR1_MSTR | SPI_CR1_SSM | SPI_CR1_SSI
              | SPI_CR1_SPE | SPI_CR1_MODE(mode)
              | SPI_CR1_BR_by4;
    SPI2->CR2 = SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN;
}

unsigned
spi_transfer(volatile void *data, unsigned count)
{
    GPIOB->BRR = 1<<12;                                 // activate SS

    DMA1_Channel4->CMAR  = (unsigned)data;              // setup memory buffer
    DMA1_Channel5->CMAR  = (unsigned)data;
    DMA1_Channel4->CNDTR = count;
    DMA1_Channel5->CNDTR = count;

    BBPeriphMask(DMA1_Channel4->CCR, DMA_CCR_EN) = 1;   // enable RX DMA
    BBPeriphMask(DMA1_Channel5->CCR, DMA_CCR_EN) = 1;   // enable TX DMA

    while (!(DMA1->ISR & DMA_ISR_TCIF4)) ;              // wait until RX DMA complete
    DMA1->IFCR = DMA_IFCR_CGIF4 | DMA_IFCR_CGIF5;       // clear DMA interrupt flags

    BBPeriphMask(DMA1_Channel4->CCR, DMA_CCR_EN) = 0;   // disable RX DMA
    BBPeriphMask(DMA1_Channel5->CCR, DMA_CCR_EN) = 0;   // disable TX DMA

    GPIOB->BSRR = 1<<12;                                // deactivate SS
}

volatile uint8_t buffer[2];

int
main(void)
{
    rcc_clock();
    usart_init();
    systick_init(F_HCLK / 100);
    spi_init(8, 0);

    for (unsigned v = 0x0001;;) {
        printf("%04X =>", v);

        buffer[0] = v;
        buffer[1] = v >> 8;
        spi_transfer(buffer, 2);
        printf(" %02X%02X\n", buffer[1], buffer[0]);
        
        v <<= 1;
        if (!(v & 0xFFFF))
            v = 0x0001;
        delay_ms(500);
    }
}

[Op C. (opcode_x64)]

Guten Tag A.K.,

vielen Dank für den Code. Ich werde diesen jetzt erst mal studieren.

[Op C. (opcode_x64)]

Ich frage mich (seit gestern :-)...), warum die Interrupt Handler z.B. 
der zum Empfangen, also Stream3, nie auslöst ?!. Versteh ich das 
richtig, dass der Interrupt Handler für Stream3, der ja hier für SPI2 RX 
steht, dann auslöst, wenn der Datentransfer von Peripherie zum Speicher 
beendet wurde, also alle Bytes empfangen worden sind.

Hier der Code:

//---------------------------------------------------------------------------------------------------
// Includes
//---------------------------------------------------------------------------------------------------
#include <stdio.h>
#include "stm32f4xx_dma.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_spi.h"
#include "misc.h"

//---------------------------------------------------------------------------------------------------
// Defines
//---------------------------------------------------------------------------------------------------
#define LED_GREEN         GPIO_Pin_12        //    Grün auf PD12
#define LED_ORANGE        GPIO_Pin_13        // Orange auf PD13
#define LED_RED         GPIO_Pin_14        //    Rot auf PD14
#define LED_BLUE         GPIO_Pin_15        //  Blaue auf PD15

#define SCLK          GPIO_Pin_10       // PB10   // Takt-Ausgang für SPI
#define SDATA          GPIO_Pin_2        // PC2   // Datenleitung für die Samples bzw. MISO
#define MOSI          GPIO_Pin_3        // PC3   // MOSI; existiert in diesem Beispiel nicht
#define CS            GPIO_Pin_3        // PA3   // ChipSelect (auch SlaveSelect genannt)

#define ADC_RES          65535          // Der AD7680 hat eine Auflösung von 16 Bit: (2^16)-1=65535 Abstufungen
#define VREF          2.94          // Referenzsspannung des A-D Umsetzer ist bei beim AD7680 die Versorgungsspannung Vss
                            // Die Versorgungsspannung des AD-Umsetzer wird dem Vdd Pin des STM32F4 Discovery Boards
                            // entnommen, die bei USB Speisung c.a. 2.94 V beträgt (Schutzdioden auf dem Board...).

#define SPI2_DMA        DMA1          // DMA Controller für den SPI2, S. 304, Tab. 43 im Reference Manual RM0090 => http://www.st.com/web/en/resource/technical/document/reference_manual/DM00031020.pdf
#define SPI2_TX_DMA_CHANNEL    DMA_Channel_0      // DMA Kanal für den SPI2 Datenversand, S. 304, Tab. 43 im Reference Manual RM0090
#define SPI2_RX_DMA_CHANNEL    DMA_Channel_0      // DMA Kanal für den SPI2 Datenempfang, S. 304, Tab. 43 im Reference Manual RM0090
#define SPI2_TX_DMA_STREAM    DMA1_Stream4      // DMA Stream für den SPI2 Datenversand, S. 304, Tab. 43 im Reference Manual RM0090
#define SPI2_RX_DMA_STREAM    DMA1_Stream3      // DMA Stream für den SPI2 Datenempfang, S. 304, Tab. 43 im Reference Manual RM0090
#define SPI2_TX_DMA_FLAG_TCIF  DMA_FLAG_TCIF4      // Interrupt-Flag für den Transfer Complete von Stream 4 des SPI2 Datenversands
#define SPI2_RX_DMA_FLAG_TCIF  DMA_FLAG_TCIF3      // Interrupt-Flag für den Transfer Complete von Stream 3 des SPI2 Datenempfangs
#define SPI2_RX_DMA_IRQHANDLER  DMA1_Stream3_IRQHandler  // Interrupt-Handler für SPI2_RX_DMA
#define SPI2_TX_DMA_IRQHANDLER  DMA1_Stream4_IRQHandler // Interrupt-Handler für SPI2_TX_DMA


#define SAMPLE_COUNT      3        // Anzahl der gewünschten Samples d.h. die Größe des SAMPLES Arrays, wo die Abtastwerte gespeichert werden

#define SPI2_DR_ADDRESS      ((uint32_t)&(SPI2->DR))    // Adresse des Datenregisters von SPI2. Wird für die Konfiguration des DMAs als 32 Bit Adresse übergeben.




//---------------------------------------------------------------------------------------------------
// Prototpes
//---------------------------------------------------------------------------------------------------
void EnableRCC(void);
void ConfigGPIO(void);
void ConfigSPI(void);
void ConfigDMA(void);
void ConfigNVIC(void);
uint8_t ReadSPI(void);
void SPI2_RX_DMA_IRQHANDLER(void);
void SPI2_TX_DMA_IRQHANDLER(void);
//---------------------------------------------------------------------------------------------------
// Global Variables
//---------------------------------------------------------------------------------------------------
__IO uint8_t SAMPLES[SAMPLE_COUNT];
__IO uint8_t DUMMYDATA[] = {0xAA, 0xAA, 0xAA};

volatile int n;
volatile int i;

int main(void)
{
  uint8_t  raw_bytes[3];                // Ein Array wo die drei "Roh-Bytes" gespeichert werden. "Roh-Bytes" sind die mit den Nullen aufgefüllten Bytes, die  vom AD7680 gesendet werden
  unsigned sample_value = 0;              // Hier wird der 16 Bit Abtastwert gespeichert
  float voltage_value = 0;              // Der berechnete Spannungswert wird hier gespeichert
  int i = 0;

  //DUMMYDATA[]                     // "dummy" Daten für SPI2_DMA_TX

  /*!! Wichtig !!*/
  SystemInit();                    // ggf. nötig, damit die Takteinstellungen richtig übernommen werden

  /* Deinitialisation */
  DMA_DeInit(SPI2_RX_DMA_STREAM);            // SPI2_RX_DMA deinitialisieren
  DMA_DeInit(SPI2_TX_DMA_STREAM);             // SPI2_TX_DMA deinitialisieren
  SPI_I2S_DeInit(SPI2);                // SPI2 deinitialisieren

  /* Konfiguration der Peripherien */
  EnableRCC();                    // Takt für die benötigten Peripherien einschalten
  ConfigGPIO();                    // Die GPIO Pins konfigurieren
  ConfigDMA();                    // DMA1 für SPI2 Datenempfang konfigurieren
  ConfigNVIC();                    // Interrupt für DMA1 konfigurieren
  ConfigSPI();                    // SPI2 Controller konfigurieren

  DMA_Cmd(SPI2_TX_DMA_STREAM, DISABLE);        // DMA1 mit Stream4 deaktivieren
  DMA_Cmd(SPI2_RX_DMA_STREAM, DISABLE);        // DMA1 mit Stream3 deaktivieren

  SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);  // SPI2 Datenempfang Request aktivieren
  SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);  // SPI2 Datenversand Request aktivieren

  SPI_Cmd(SPI2, ENABLE);                // SPI2 Interface aktivieren

  GPIO_SetBits(GPIOD,LED_BLUE);            // blaue LED einschalten (Lebenszeichen)

  //DMA_SetCurrDataCounter(SPI2_TX_DMA_STREAM,3);

   GPIO_ResetBits(GPIOA,CS);              // ChipSelect Ausgang auf Low setzen, damit der AD7680 mit Abtastvorgang anfängt
   DMA_Cmd(SPI2_RX_DMA_STREAM, ENABLE);        // DMA1 mit Stream3 aktivieren
   DMA_Cmd(SPI2_TX_DMA_STREAM, ENABLE);        // DMA1 mit Stream4 aktivieren

  while(1)
    {
    //GPIO_ResetBits(GPIOA,CS);              // ChipSelect Ausgang auf Low setzen, damit der AD7680 mit Abtastvorgang anfängt
      for(i=0; i<3; i++)
      {
      // raw_bytes[i]=ReadSPI();            // Alle drei "Roh-Bytes" in das Array speichern
      }
      //GPIO_SetBits(GPIOA,CS);              // ChipSelect Ausgang auf High setzen, damit der AD7680 mit Abtastvorgang aufhört

      //sample_value = (raw_bytes[0] << 11) | (raw_bytes[1] << 3) | (raw_bytes[2] >> 5);   // Da wir 3 Bytes (24 Bit) erhalten, müssen wir Bits verschieben um an die
                                                // relevanten 16 Bit Daten (Abtastwert) heranzukommen.
      //voltage_value=(VREF/ADC_RES)*sample_value;  // Spannungswert aus dem Abtastwert (16 Bit ADC Wert) berechnen
      //i++;
    }
}


uint8_t ReadSPI(void)
{
    SPI2->DR = 0xAA;                  // "dummy" Daten schreiben, dies ist nötig, damit überhaupt Empfangen werden kann.
    while( !(SPI2->SR & SPI_I2S_FLAG_TXE));     // warten bis der Sendevorgang abgeschlossen ist
    while( !(SPI2->SR & SPI_I2S_FLAG_RXNE));     // warten bis der Datenempfang abgeschlossen ist
    while(   SPI2->SR & SPI_I2S_FLAG_BSY);        // warten bis der SPI2 nicht mehr "beschäftigt" ist.
    return SPI2->DR;                 // Daten im SPI2 Datenregister als Rückgabewert ausgeben
}


void ConfigSPI()
{
  SPI_InitTypeDef SPI_InitStructure;

  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;      // Daten empfangen und senden
  SPI_InitStructure.SPI_Mode    = SPI_Mode_Master;               // STM32F407VGT ist der Master und AD7680 der Slace
  SPI_InitStructure.SPI_DataSize   = SPI_DataSize_8b;              // Es werden 24 Bit's vom AD7680 ausgegeben 000016_Bit_Sample_Value0000, daher 3 x 8 Bit Packete
  SPI_InitStructure.SPI_DataSize   = SPI_FirstBit_MSB;              // Der AD7680 überträgt die Daten als "MSB first"
  SPI_InitStructure.SPI_CPOL     = SPI_CPOL_High;              // Clock Polarity (CPOL) = 1
  SPI_InitStructure.SPI_CPHA     = SPI_CPHA_2Edge;              // Clock Phase (CPHA) = 1 (entspricht hier CPHA_2Edge !)
  SPI_InitStructure.SPI_NSS     = SPI_NSS_Soft | SPI_NSSInternalSoft_Set;  // NSS Pin als GPIO Pin einstellen und intern auf High setzen

  SPI_InitStructure.SPI_BaudRatePrescaler  = SPI_BaudRatePrescaler_64;      // SCLK=42MHz/64=656.2kHz APB1=42 MHz, SYSCLK=168 MHz
  SPI_InitStructure.SPI_CRCPolynomial   = 0;                // kein CRC bilden

  SPI_Init(SPI2, &SPI_InitStructure);                      // SPI2 Interface initialisieren
  SPI_CalculateCRC(SPI2, DISABLE);                      // CRC Berechnung deaktivieren

}


void EnableRCC(void)
{
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);  // Takt für die GPIOA's aktivieren
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);  // Takt für die GPIOB's aktivieren
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);  // Takt für die GPIOC's aktivieren
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);  // Takt für die GPIOD's aktivieren
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2,  ENABLE);  // Takt für den SPI2 aktivieren
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1,  ENABLE);  // Takt für DMA1 aktivieren
}


void ConfigGPIO(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;


  //---------------------------------------------------------------------------------------------------
  // Pin für die blaue LED (PD15) konfigurieren
  //---------------------------------------------------------------------------------------------------
  GPIO_InitStructure.GPIO_Pin   = LED_BLUE | LED_ORANGE | LED_GREEN;
  GPIO_InitStructure.GPIO_Mode   = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType  = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd   = GPIO_PuPd_NOPULL;
  GPIO_InitStructure.GPIO_Speed   = GPIO_Speed_50MHz;

  GPIO_Init(GPIOD, &GPIO_InitStructure);
  //---------------------------------------------------------------------------------------------------

  //---------------------------------------------------------------------------------------------------
  // SCLK Ausgang konfigurieren
  // -restliche Einstellungen können aus der LED Konfiguration übernommen werden.
  //---------------------------------------------------------------------------------------------------
  GPIO_InitStructure.GPIO_Pin   = SCLK;
  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF;       // SCLK, also PB10, auf Alternativ-Modus umschalten

  GPIO_Init(GPIOB, &GPIO_InitStructure);

  GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_SPI2);   // PB10 mit dem SPI2 Controller verbinden
                                 // PB10 ist nun die SCLK Quelle
  //---------------------------------------------------------------------------------------------------

  //---------------------------------------------------------------------------------------------------
  // SDATA (MISO) und MOSI konfigurieren
  //---------------------------------------------------------------------------------------------------
  GPIO_InitStructure.GPIO_Pin   = SDATA | MOSI;
  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF;        // PC2 und PC3 auf Alternativ-Modus umschalten

  GPIO_Init(GPIOC, &GPIO_InitStructure);

  GPIO_PinAFConfig(GPIOC, GPIO_PinSource2, GPIO_AF_SPI2);   // PC2 mit SDATA(MISO) von SPI2 verbinden
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource3, GPIO_AF_SPI2);   // PC3 mit MOSI von SPI2 verbinden
  //---------------------------------------------------------------------------------------------------

  //---------------------------------------------------------------------------------------------------
  // ChipSelect(CS) bzw. SlaveSelect(SS) konfigurieren
  //---------------------------------------------------------------------------------------------------
  GPIO_InitStructure.GPIO_Pin   = CS;
  GPIO_InitStructure.GPIO_Mode   = GPIO_Mode_OUT;      // Normaler Ausgang...
  GPIO_InitStructure.GPIO_PuPd   = GPIO_PuPd_UP;        // PullUp aktivieren
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  GPIO_SetBits(GPIOA,CS);                    // ChipSelect sofort auf High setzen,
                                // damit der AD7680 nicht gleich anfängt
                                // zu "arbeiten".
  //---------------------------------------------------------------------------------------------------
}


void ConfigDMA(void)
{

  DMA_InitTypeDef DMA_InitStructure;

  /* Konfiguration für SPI_DMA_RX und SPI_DMA_TX */
  DMA_InitStructure.DMA_Mode          = DMA_Mode_Normal;            // Normaler Modus: Kein Datentransfer mehr, wenn der Speicher SAMPLES voll ist bzw. SAMPLE_COUNT erreicht wurde
  DMA_InitStructure.DMA_Priority        = DMA_Priority_High;          // Prioriät des Datenflusses von Kanal 0 auf hoch setzen.
  DMA_InitStructure.DMA_FIFOMode        = DMA_FIFOMode_Disable;          // Kein First In First Out aktivieren
  DMA_InitStructure.DMA_FIFOThreshold      = DMA_FIFOThreshold_1QuarterFull;
  DMA_InitStructure.DMA_MemoryBurst        = DMA_MemoryBurst_Single;
  DMA_InitStructure.DMA_PeripheralBurst     = DMA_PeripheralBurst_Single;
  DMA_InitStructure.DMA_PeripheralBaseAddr  = (uint32_t)SPI2_DR_ADDRESS;      // Adresse des Datenregisters der jeweiligen Peripherie, hier SPI2.
    DMA_InitStructure.DMA_PeripheralInc      = DMA_PeripheralInc_Disable;      // Peripherieadresse nicht inkrementieren.
    DMA_InitStructure.DMA_PeripheralDataSize    = DMA_PeripheralDataSize_Byte;      // Datengröße in der Peripherie, also des SPI's. Entspricht hier 32-Bit.
    DMA_InitStructure.DMA_MemoryDataSize      = DMA_MemoryDataSize_Byte;        // Datengröße der Speicherstelle. Entspricht hier ebenfals 32-Bit.

    /* Konfiguration nur für SPI2_DMA_TX */
    DMA_InitStructure.DMA_Memory0BaseAddr      = (uint32_t)&DUMMYDATA;          // Adresse der "Dummy-Daten", die verschickt werden müssen, damit wir überhaupt was empfange können.
    DMA_InitStructure.DMA_DIR            = DMA_DIR_MemoryToPeripheral;      // Datenflussrichtung: von dem Speicher zur Peripherie, da wir Daten ("Dummy-Daten") in den SPI2 Datenregister laden wollen, um diese zu verschicken.
    DMA_InitStructure.DMA_BufferSize        = 3;                  // Die Größe des Speichers der "Dummy-Daten", hier 1, da wir immer nur die gleihen "Dummy-Daten" verschicken müssen.
    DMA_InitStructure.DMA_MemoryInc        = DMA_MemoryInc_Enable;          // Speicherinkrementierung deaktivieren. Es gibt nur ein "Dummy-Daten" Eintrag im Array DUMMYDATA.
  DMA_InitStructure.DMA_Channel         = SPI2_TX_DMA_CHANNEL;          // siehe oben in den "Defines"
    DMA_Init(SPI2_TX_DMA_STREAM, &DMA_InitStructure);                      // SPI2 hängt am ABP1 und dafür ist der DMA1 zuständig. (S. 18, Fig. 5 Datenblatt des STM32F407VGT6)
                                              // Der Datenversand (SPI2_DMA_TX) erfolgt über Stream 4. (S. 18, Fig. 5 Datenblatt des STM32F407VGT6)
                                              // http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00037051.pdf

    /* Konfiguration nur für SPI_DMA_RX */
  DMA_InitStructure.DMA_Mode          = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Memory0BaseAddr      = (uint32_t)&SAMPLES;          // Der Speicher bzw. die Variable(Array) wo die Abtastwerte gespeichert werden sollen. Muss auch als 32-Bit angegeben werden.
    DMA_InitStructure.DMA_DIR            = DMA_DIR_PeripheralToMemory;      // Datenflussrichtung: von der Peripherie zum Speicher, also wir lesen aus dem SPI2 Datenregister in die Variable/Array SAMPLES, die im RAM ist.
    DMA_InitStructure.DMA_BufferSize        = SAMPLE_COUNT;              // Die Größe des Speichers, hier die Anzahl der gewünschten Abtastwerte (Samples)
    DMA_InitStructure.DMA_MemoryInc        = DMA_MemoryInc_Enable;          // Speicherinkrementierung aktivieren d.h. die neuen Daten werden nacheinander in das Array (SAMPLES) gespeichert.
  DMA_InitStructure.DMA_Channel         = SPI2_RX_DMA_CHANNEL;          // siehe oben in den "Defines"
    DMA_Init(SPI2_RX_DMA_STREAM, &DMA_InitStructure);                  // SPI2 hängt am ABP1 und dafür ist der DMA1 zuständig. (S. 18, Fig. 5 Datenblatt des STM32F407VGT6)
                                                // Der Datenversand (SPI2_DMA_RX) erfolgt über Stream 3. (S. 18, Fig. 5 Datenblatt des STM32F407VGT6)
                                                // http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00037051.pdf

    DMA_ITConfig(SPI2_TX_DMA_STREAM, DMA_IT_TC, ENABLE);                // Interrupt Routine ausführen, wenn der Datentransfer des DMA beendet ist.
    DMA_ITConfig(SPI2_RX_DMA_STREAM, DMA_IT_TC, ENABLE);                // Interrupt Routine ausführen, wenn der Datentransfer des DMA beendet ist.
}



void ConfigNVIC(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;

      NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream3_IRQn;          // IRQ Kanal (Stream3 von DMA1) angeben
      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;        // Präemptiv Priorität-Level auf 0 (Höchste Prioriät) (ist eigentlich egal, da wir keinen anderen Interrupt konfiguriert haben ?!)
      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;            // Sub Priorität ebenfalls auf 0 setzen
      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;              // Interrupt aktivieren
      NVIC_Init(&NVIC_InitStructure);
}


/* Interrupt Handler für SPA_DMA_RX */
void SPI2_RX_DMA_IRQHANDLER(void)
  {

  GPIO_SetBits(GPIOD,LED_GREEN);

  //GPIO_SetBits(GPIOA,CS);

  //DMA_ClearFlag(SPI2_RX_DMA_STREAM, SPI2_RX_DMA_FLAG_TCIF);

  /*if(DMA_GetITStatus(SPI2_RX_DMA_STREAM, SPI2_RX_DMA_FLAG_TCIF) == SET)
      {
        n++;
        // GPIO_SetBits(GPIOD,LED_ORANGE);
        // GPIO_SetBits(GPIOA,CS);
        // DMA_ClearITPendingBit(DMA1_Stream3, DMA_IT_TCIF3);
        DMA_ClearFlag(SPI2_RX_DMA_STREAM, SPI2_RX_DMA_FLAG_TCIF);
      }*/
  }


/* Interrupt Handler für SPA_DMA_TX */
void SPI2_TX_DMA_IRQHANDLER(void)
  {
   GPIO_SetBits(GPIOD,LED_ORANGE);

   // GPIO_SetBits(GPIOA,CS);
   // GPIO_SetBits(GPIOD,LED_ORANGE);
  /* if(DMA_GetITStatus(SPI2_TX_DMA_STREAM, SPI2_TX_DMA_FLAG_TCIF) == SET)
      {
      n++;
      //GPIO_SetBits(GPIOD,LED_ORANGE);
        //GPIO_SetBits(GPIOA,CS);
          //DMA_ClearITPendingBit(DMA1_Stream3, DMA_IT_TCIF3);
        DMA_ClearFlag(SPI2_TX_DMA_STREAM, SPI2_TX_DMA_FLAG_TCIF);
      }*/
  }