STM32F4 - SPI und DMA

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);

    }

}

//---------------------------------------------------------------------------------------------------

// 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);

      }*/

  }