Verständnisprobleme mit SPI, STM32, Interrupt, wie Senden/Empfangen?

[Alex (Gast)]

Hi

Ich lese mich seit gestern in die SPI Kommunikation ein und verwendet 
das STM32F407 discovery board dazu.
Macht es Sinn, SPI über Interrupts laufen zu lassen? Oder kommt es auf 
die Situation drauf an? Normalerweise möchte ich blockende Schleifen 
nämlich vermeiden.

Allerdings sehe ich viele Tutorials, in denen der Interrupt nicht 
verwendet wird mit dem Argument, dass 8bits bei z.B. 8MHz SPI_Clock in 
Nullkommanichts gesendet wurden und Interrupts overkill seien.

Wie ist die richtige Vorgehensweise? Interrupt ja oder nein? Aktueller 
Stand bei mir ist, dass ich die Zahl 100 vom STM32 senden und mittels 
Logic Analyzer auch die Datenbits richtig lesen kann.

Ist die von mir implementierte Vorgehensweise richtig, oder wie sollte 
man SPI idealerweise implementieren?

PS: Ich weiß, dass meine SPIInit() Funktion mehr als unschön ist, und 
man das wesentlich überschaulicher/eleganter schreiben kann. Allerdings 
hat mir diese Schreibweise mehr als einmal beim Debugging geholfen, 
weshalb ich zunächst einmal diese Schreibweise fortführe.

Vielen Dank für eure Hilfe.
Gruß,

#if !defined(__SOFT_FP__) && defined(__ARM_FP)
  #warning "FPU is not initialized, but the project is compiling for an FPU. Please initialize the FPU before use."
#endif

#include "stm32f4xx.h"

void funcSPIInit();
void funcIntInit();

uint8_t TXvariable = 100;
//char testvar[] = "Alex";

int main(void)
{
  funcIntInit();
  funcSPIInit();

  for(;;)
  {
    while(SPI1->SR & SPI_SR_BSY)
    {

    }
    for(int i = 0; i<10000; i++)
    {
      for(int k = 0; k<10000; k++)
      {
        SPI1->CR2 |= (1<<SPI_CR2_TXEIE_Pos);      // TX buffer empty interrupt request enabled
        SPI1->CR2 |= (1<<SPI_CR2_RXNEIE_Pos);      // RX buffer full interrupt request enabled
      }
    }
  }
}

void funcIntInit()
{
  // Initializes the interrupt
  __NVIC_EnableIRQ(SPI1_IRQn);
}

void funcSPIInit()
{
  // Enable bus for SPI1
  RCC->APB2ENR |= (1<<RCC_APB2ENR_SPI1EN_Pos);  // SPI1 bus enable
  // Enable bus for GPIOA
  RCC->AHB1ENR |= (1<<RCC_AHB1ENR_GPIOAEN_Pos);  // GPIOA bus enable
  // Set GPIO to AF5
  GPIOA->MODER |= (2 << GPIO_MODER_MODER4_Pos);  // PA4 to AF
  GPIOA->AFR[0] |= (0x5<<GPIO_AFRL_AFSEL4_Pos);  // PA4 to AF5 [0101]: SPI1_NSS
  GPIOA->OTYPER &= ~(1<<GPIO_OTYPER_OT4_Pos);    // PA4 to Push pull output
  GPIOA->PUPDR &= ~(0x3UL << GPIO_PUPDR_PUPD4_Pos);  // PA4 no pull up_down resistor
  GPIOA->OSPEEDR &= ~(0x3UL << GPIO_OSPEEDR_OSPEED4_Pos);  // PA4 low speed
  GPIOA->MODER |= (2 << GPIO_MODER_MODER5_Pos);  // PA5 to AF
  GPIOA->AFR[0] |= (0x5<<GPIO_AFRL_AFSEL5_Pos);  // PA5 to AF5 [0101]: SPI1_SCK
  GPIOA->OTYPER &= ~(1<<GPIO_OTYPER_OT5_Pos);    // PA5 to Push pull output
  GPIOA->PUPDR &= ~(0x3UL << GPIO_PUPDR_PUPD5_Pos);  // PA5 no pull up_down resistor
  GPIOA->OSPEEDR &= ~(0x3UL << GPIO_OSPEEDR_OSPEED5_Pos);  // PA5 low speed
  GPIOA->MODER |= (2 << GPIO_MODER_MODER6_Pos);  // PA6 to AF
  GPIOA->AFR[0] |= (0x5<<GPIO_AFRL_AFSEL6_Pos);  // PA6 to AF5 [0101]: SPI1_MISO
  GPIOA->OTYPER &= ~(1<<GPIO_OTYPER_OT6_Pos);    // PA6 to Push pull output
  GPIOA->PUPDR &= ~(0x3UL << GPIO_PUPDR_PUPD6_Pos);  // PA6 no pull up_down resistor
  GPIOA->OSPEEDR &= ~(0x3UL << GPIO_OSPEEDR_OSPEED6_Pos);  // PA6 low speed
  GPIOA->MODER |= (2 << GPIO_MODER_MODER7_Pos);  // PA7 to AF
  GPIOA->AFR[0] |= (0x5<<GPIO_AFRL_AFSEL7_Pos);  // PA7 to AF5 [0101]: SPI1_MOSI
  GPIOA->OTYPER &= ~(1<<GPIO_OTYPER_OT7_Pos);    // PA7 to Push pull output
  GPIOA->PUPDR &= ~(0x3UL << GPIO_PUPDR_PUPD7_Pos);  // PA7 no pull up_down resistor
  GPIOA->OSPEEDR &= ~(0x3UL << GPIO_OSPEEDR_OSPEED7_Pos);  // PA7 low speed

  // Configure SPI
  SPI1->CR1 &= ~(0x7UL << SPI_CR1_BR_Pos);    // Sets BR to 111. SPI runs with 16MHz/2=8MHz
  SPI1->CR1 |= (1<<SPI_CR1_CPHA_Pos);        // CPHA: 2nd clock transition
  SPI1->CR1 |= (1<<SPI_CR1_CPOL_Pos);        // CPOL: 1 when idle
  SPI1->CR1 &= ~(1<<SPI_CR1_DFF_Pos);        // 8bit
  SPI1->CR1 &= ~(1<<SPI_CR1_LSBFIRST_Pos);    // MSB first
  SPI1->CR1 &= ~(1<<SPI_CR1_SSM_Pos);        // Software slave management disabled
  SPI1->CR2 |= (1<<SPI_CR2_SSOE_Pos);        // SSOE enable
  SPI1->CR2 &= ~(1<<SPI_CR2_FRF_Pos);        // Motorola Mode
  SPI1->CR1 |= (1<<SPI_CR1_MSTR_Pos);        // Master configuration
  SPI1->CR1 &= ~(1<<SPI_CR1_BIDIMODE_Pos);    // Full duplex
  SPI1->CR1 &= ~(1<<SPI_CR1_RXONLY_Pos);      // Transmit and Receive
  SPI1->CR1 |= (1<<SPI_CR1_SPE_Pos);        // Peripheral enabled
}

void SPI1_IRQHandler()
{
    //Todo
  SPI1->DR = TXvariable;
  SPI1->CR2 &= ~(1<<SPI_CR2_TXEIE_Pos);      // TX buffer empty interrupt request disabled

}

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

SPI ist durchaus so schnell einstellbar, dass IRQ Betrieb keinen 
wirklichen Sinn ergibt.
Wenn du ein "fire and forget" mit dem SPI machen willst und nicht warten 
willst -> DMA.
Das gibt am Ende nur ein "DMA hat fertig" IRQ.

Ansonsten empfehle ich dir für Pins eine Initfunktion zu schreiben, dann 
musste das nicht imemr per hand machen (was auch fehlerträchtig ist)